C++ - std-Header Reference | wedi

You are here

C++ - std-Header Reference

// Literatur: Vorlesungsunterlagen SEN (FH Hagenberg, HSSE Semester 2)
//            C++ Referenz (http://www.cplusplus.com)
 
// Strings
    #include <string>
    string s("test");
    s.size();
    s.clear();
    bool isEmpty = s.empty();
    s[0] = 'f';
    s.at(0) = 'f';
 
    s += "next";
    s += str2;
    s += 'c';
 
    s.append(str2);
    s.append(str2, 2, 3);           // ab Zeichen 2, 3 Zeichen lang
    s.append("asdf");
    s.append("asdfasdf", 4);        // 4 Zeichen vom String
    s.append(10,'.');               // 10 x '.'
    s.append(firstIter, secondIter);
 
    s.push_back('c');
 
    s.assign(str2);
    s.assign(str2, 2, 3);           // ab Zeichen 2, 3 Zeichen lang
    s.assign("asdf");
    s.assign("asdfasdf", );         // 4 Zeichen vom String
    s.assign(10, '.');              // 10 x '.'
    s.assign(firstIter, secondIter);
 
    s.insert(2, str2);              // String an Position 2 einfügen
    s.insert(2, str2, 3, 4);        // String an Position 2 einfügen,
                                    // ab Zeichen 3, 4 Zeichen lang
    s.insert(2, "asdf");            // String an Position 2 einfügen
    s.insert(2, "asdfasdf", 4);     // String an Position 2 einfügen,
                                    // 4 Zeichen vom String
    s.insert(2, 10, '.');           // an Position 2, 10 x '.' einfügen
    s.insert(iter, '.');
    s.insert(iter, 10, '.');
    s.insert (iter, str2.begin(), str2.end);
 
    s.erase(iter);
    s.erase(firstIter, secondIter);
 
    s.replace(2, 3, str2);          // String an Position 2,
                                    // 3 Zeichen lang ersetzen mit str2
    s.replace(2, 3, str2, 4, 5);    // String an Position 2,
                                    // 3 Zeichen lang ersetzen mit str2
                                    // (ab Position 4, 5 Zeichen lang)
    s.replace(2, 3, "asdf");        // String an Position 2,
                                    // 3 Zeichen lang ersetzen mit String
    s.replace(2, 3, "asdfasdf", 4); // String an Position 2,
                                    // 3 Zeichen lang ersetzen mit str2
                                    // (4 Zeichen vom String)
    s.replace(2, 3, 10, '.');       // String an Position 2,
                                    // 3 Zeichen lang ersetzen mit 10 x '.'
    s.replace(firstIter, secondIter, str2);
    s.replace(firstIter, secondIter, "asdf");
    s.replace(firstIter, secondIter, "asdfasdf", 4);
    s.replace(firstIter, secondIter, 10, '.');
    s.replace(firstIter, secondIter, str2.begin(), str2.end());
 
    s.copy(charArr, 2, 3);          // String ab Position 2,
                                    // 3 Zeichen lang in charArr kopieren
    s.swap(str2);
    s.c_str();
 
    size_t position = s.find(str2);
    if (position != string::npos)
        ...
    s.find(str2, 2);                // Suche ab Position 2
    s.find("asdf");
    s.find("asdf", 2);              // Suche ab Position 2
    s.find("asdf", 2, 3);           // Suche ab Position 2, 3 Zeichen lang
    s.find('a');
    s.find('a', 2);                 // Suche ab Position 2
    s.rfind(...);                   // von hinten Suchen
 
    string s("alle Selbstlaute durch Punkt ersetzen");
    size_t position;
    position = s.find_first_of("aeiou");
    while (position != string::npos)
    {
        s[position] = '.';
        position = s.find_first_of("aeiou", position + 1);
    }                       // s = ".ll. S.lbstl..t. d.rch P.nkt .rs.tz.n."
    s.find_last_of(...);
    s.find_first_not_of(...);
    s.find_last_not_of(...);
 
    str2 = s.substr();              // str2 == s
    str2 = s.substr(2);             // von Position 2 bis zum Ende
    str2 = s.substr(2, 3);          // von Position 2, 3 Zeichen lang
 
    s.compare(str2) == 0            // Strings gleich
    s.compare("asdf")
    s.compare(2, 3, str2)           // s ab Position 2,
                                    // 3 Zeichen lang vergleichen
    s.compare(2, 3, str2, 4, 5)     // s ab Position 2,
                                    // 3 Zeichen lang mit str2 ab Position 4,
                                    // 5 Zeichen lang vergleichen
    s.compare(2, 3, "asdf")         // s ab Position 2,
                                    // 3 Zeichen lang vergleichen
    s.compare(2, 3, "asdf", 4)      // s ab Position 2, 3 Zeichen lang mit
                                    // ".." 4 Zeichen lang vergleichen
 
 
// Streams
    #include <iostream>
    cout << "text" << var << endl;  // standard Ausgabe
    cin >> intVal;                  // standard Eingabe
 
    #include <fstream>
    ofstream out("file.txt");
    out << "text";
    out.close();
            .is_open()
            .put(char c)
            .write(const char* c, streamsize maxc)
            .flush
            .eof()
            .fail()
 
    ifstream in("file.txt");
    in >> intVal;
    in.close();
            .is_open()
            .get(char &c)
            .getline(char *c, streamsize maxc)
            .read(char *c, streamsize maxc)
            .eof()
            .fail()
 
// String Streams
    #include <sstream>
    ostringstream oss;
    oss << "text";
    oss.str();
 
    istringstream iss(string);
    iss >> intVal;
 
 
// Stream-Manipulatoren
    hex                             // Hexadezimalausgabe (bis auf Widerruf)
    oct                             // Oktalausgabe
    dec                             // Dezimalausgabe
 
    scientific                      // Exponenten Darstellung
    fixed                           // normale Darstellung
 
    setprecision(4)                 // Nachkommastellen für nächste Ausgabe
    setw(3)                         // Weite der Zahl
    setfill('0')                    // Füllzeichen setzen
 
    left                            // Ausrichtung
    right
 
    upercase                        // Großschreibung
    nouppercase
 
    boolalpha                       // Ausgabe von true/false
    noboolalpha
 
    ostream &hr (ostream &os)       // eigener Manipulator
    {
        os << endl;
        os << "-------------";
        os << endl;
        return os;
    }
 
 
// Container
//      Queue - FIFO Datenstruktur
    queue<int> q;
    q.push(1);                      // fügt Element am Ende ein
    ivalue = q.front();             // liefert Element am Anfang
    q.pop();                        // löscht Element am Anfang
 
//      Stack - LIFO Datenstruktur
    stack<int> s;
    s.push(1);                      // fügt Element oben ein
    ivalue = s.top();               // liefert oberstes Element
    s.pop();                        // löscht oberstes Element
 
//      Vektor - automatisch wachsendes Array
//          + schnelles Einfügen/Löschen am Ende
//          + Direktzugriff mit Indexoperator
    #include <vector>
    vector<int> v;
    v.push_back(0);                 // fügt Element am Ende ein
    v[0]                            // Zugriff auf Element an Stelle 0
    v.erase(iter);                  // Element löschen
    v.erase(v.begin(), iter);       // Bereich löschen
    v.empty()                       // Überprüfung ob leer
    v.size()                        // Ausgabe der Größe
    v.pop_back();                   // Element am Ende löschen
    v.clear();                      // Container löschen
 
//      Liste - doppelt verkettete Liste
//          + schnelles Einfügen/Löschen an jeder Position
//          - nur sequentiellen Zugriff (beide Richtungen)
    #include <list>
    list<int> l;
    l.insert(iter, 0);              // Einfügen eines Elements an
                                    // bestimmten Iterator-Position
    l.push_front(0);                // fügt Element am Anfang ein
    l.push_back(0);                 // fügt Element am Ende ein
    l.pop_front();                  // Element am Anfang löschen
    l.pop_back();                   // Element am Ende löschen
    l.front();                      // liefert Element vom Anfang
    l.back();                       // liefert Element vom Ende
    l.sort();                       // Elemente sortieren
    l.reverse();                    // Ordnung der Elemente vertauschen
    l.clear();                      // Container löschen
    l.removeif(prädikat);           // Löscht Elemente,
                                    // welche Bedingung erfüllen
    l.remove(0);                    // Löscht alle Elemente mit gleichen Wert
 
//      Map - assoziativer Container mit Schlüssel/Werte Paar
//            (eindeutige Schlüssel)
//          + Einfügen und Suchen von Schlüsseln in logarithmischer Zeit
//          + Löschen von Schlüsseln in konstanter Zeit
//          + aufsteigend geordnet nach Schlüssel
    #include <map>
    map<string, int> m;
    m.insert(pair<string, int>("test", 100));
 
    pair<map<string, int>::iterator, bool> ret;
    ret = m.insert(pair<string, int>("test", 100));
    if (ret.second == false)
    {
        cout << "Element existiert bereits: " << ret.first->second << endl;
    }
 
    m.erase(iter);
    m.erase("test");
    m.erase(firstIter, secondIter);
    m.clear();
    m.find("test")->second;
    m.count("test");
    m.size();
    m.empty();
    m["test2"] = 50;
 
//      Set - assoziativer Container mit Schlüsseln (eindeutige Schlüssel)
//          + Einfügen und Suchen von Schlüsseln in logarithmischer Zeit
//          + Löschen von Schlüsseln in konstanter Zeit
//          + aufsteigend geordnet nach Schlüssel
    #include <set>
    set<string> s;
    s.insert("test");
    s.erase(iter);
    s.erase("test");
    s.erase(firstIter, secondIter);
    s.clear();
    iter = s.find("test");
    s.count("test");
    s.size();
    s.empty();
 
//      Bitset
    #include<bitset>
    bitset<4> b;
    b.set();                // alle Bits setzen
    b.set(2);               // Bit an Position 2 setzen
    b.set(2, true);         // Bit an Position 2 setzen
    b.set(2, false);        // Bit an Position 2 löschen
 
    b.reset();              // alle Bits löschen
    b.reset(2);             // Bit an Position 2 löschen
 
    b.flip();               // alle Bits negieren
    b.flip(2);              // Bit an Position 2 negieren
 
    int size = b.size();    // Anzahl der Bits
    int cnt = b.count();    // Anzahl an gesetzten Bits
    bool erg = b.any();     // true, wenn irgend ein Bit gesetzt
    bool erg = b.none();    // true, wenn kein Bit gesetzt
    bool erg = b.test(2);   // true, wenn Bit an Position 2 gesetzt
 
 
    dequeue     // ... double ended queue
                //     + schnelles Einfügen/Löschen am Anfang und am Ende
    slist       // ... einfach verkettete Liste
                //     + benötigt weniger Speicher
                //     - Durchlauf nur in eine Richtung
    multimap    // ... Schlüssel/Werte Paare
                //     (mehrfache Verwendung von Schlüssel erlaubt)
    multiset    // ... Schlüssel (mehrfache Verwendung von Schlüssel erlaubt)
 
 
// Iteratoren
    vector<int>::iterator iter = vec.begin();
    vector<int>::const_iterator citer = vec.end();
    vector<int>::reverse_iterator riter = vec.rbegin();
    vector<int>::reverse_const_iterator rciter = vec.rend();
 
    back_inserter(Container)
    forward_inserter(Container)
    inserter(Container, Container.end())
 
    distance(firstIter, secondIter)     // Abstand der Iteratoren
    advance(Iter, distance)             // Iterator weiter setzen
 
// Stream Iteratoren
    istream_iterator<int> in(cin);
    istream_iterator<int> eos;
    copy(in, eos, back_inserter(vec));
 
    ostream_iterator<int> out(cout, " ");
    copy(vec.begin(), vec.end(), out);
 
 
// Prädikate
    bool Pred(int x, int y)         // true  ... Aktion wird ausgeführt
    {                               // false ... Aktion wird nicht ausgeführt
        return x > y;
    }
 
    bool Pred(int x)
    {
        return x >= 0;
    }
 
    plus<>
    minus<>
    multiplies<>
    divides<>
    modulus<>
    negate<>
 
    logical_and<>
    logical_not<>
    logical_or<>
 
    equal_to<>
    not_equal_to<>
    greater<>
    greater_equal<>
    less<>
    less_equal<>
 
 
// Algorithmen
    #include <algorithm>
    fill(v.begin(), v.end(), 0);
    fill_n(v.begin(), 3, 0);
    fill_n(back_inserter(v), 10, 0);
 
    generate(v.begin(), v.end(), Func);
    generate(v.begin(), 3, Func);
 
    copy(c1.begin(), c1.end(), back_inserter(c2));
    copy(c1.begin(), c1.end(), ostream_iterator<int>(cout, " "));
    copy_backward(c1.begin(), c1.end(), ...);
 
    iter = find(v.begin(), v.end(), 5);
    iter = find_if(v.begin(), v.end(), Pred);
 
    count(v.begin(), v.end(), Elem);
    count_if(v.begin(), v.end(), Pred);
    for_each(v.begin(), v.end(), Func);
    bool vorhanden = binary_search(v.begin(), v.end(), 5);
 
    bool gleich = equal(v.begin(), v.end(), v2.begin());
    bool gleich = equal(v.begin(), v.end(), v2.begin(), Pred);
    bool kleiner = lexicographical_compare(v.begin(), v.end(),
                                           v2.begin(), v2.end());
    bool kleiner = lexicographical_compare(v.begin(), v.end(),
                                           v2.begin(), v2.end(), Pred);
 
    elemC = max(elemA, elemB);
    elemC = max(elemA, elemB, Pred);
    iterC = max_element(v.begin(), v.end());
    iterC = max_element(v.begin(), v.end(), Pred);
    min
    min_element
 
    transform(v.begin(), v.end(), v.begin(), negate<int>());
    transform(str.begin(), str.end(), str.begin(), toupper);
    transform(v1.begin(), v1.begin()+5, v2.begin(),
              vres.begin(), plus<int>());
 
    sum = accumulate(v.begin(), v.end(), 0);
    prod = accumulate(v.begin(), v.end(), 1, multiplies<int>());
 
    sort(v.begin(), v.end());
    sort(v.begin(), v.end(), Pred);
    stable_sort(v.begin(), v.end());
    stable_sort(v.begin(), v.end(), Pred);
 
    merge(v.begin(), v.end(), v2.begin(), v2.end(), vres.begin());
    merge(v.begin(), v.end(), v2.begin(), v2.end(), vres.begin(), Pred);
 
 
// Operationen für nicht initialisierte Container
    uninitialized_copy
    uninitialized_fill
    uninitialized_fill_n
 
 
// Funktions Adaptoren
    bind1st(divide<int>(), 10)
    bind2nd(divide<int>(), 10)
 
    bind2nd(not2(less<int>()), 10)  =  not1(bind2nd(less<int>(), 10))
 
    char* chNrs[] = {"10","20","30"};
    int intNrs[3];
    transform(chNrs, chNrs+3, intNrs, ptr_fun(atoi));
 
    vector<string*> v;
    v.push_back(new string("asdf"));
    v.push_back(new string("asdfasdf"));
    vector<int> lengths(v.size());
    transform(v.begin(), v.end(), lengths.begin(), mem_fun(&string::length));
 
    vector<string> v;
    v.push_back("asdf");
    v.push_back("asdfasdf");
    vector<int> lengths(v.size());
    transform(v.begin(), v.end(), lengths.begin(),
              mem_fun_ref(&string::length));
 
 
 
 
// generische Algorithm
    template <typename TIter, typename T>
    TIter find(TIter first, TIter second, T const &val)
    {
        while ((first != second) && (*first != val))
        {
            first++;
        }
        return first;
    }
 
    template <typename TIter, typename TPred>
    TIter find_if(TIter first, TIter second, TPred p)
    {
        while((first != second) && !p(*first))
        {
            first++;
        }
        return first;
    }
 
    template <typename TInItor, typename TOutIter>
    TOutIter copy(TInIter first, TInIter second, TOutIter result)
    {
        for(; first!=second; first++)
        {
            *result = *first;
        }
        return result;
    }
 
 
// Funktoren
    template <typename T>
    class multiplies: public binary_function<T,T,T>
    {
    public:
        T operator() (T const &x, T const &y) const
        {
            return x*y;
        }
    };
 
    class startsWith: public unary_function<string,bool>
    {
    public:
        startsWith(char ch): startCh(ch){}
        bool operator() (string const &str) const
        {
            return ((str.length() > 0) && (str[0] == startCh));
        }
    private:
        char startCh;
    };
    startsWith('A')
 
    class startsWithChar: public binary_function<string,char,bool>
    {
    public:
        bool operator() (string const &str, char ch) const
        {
            return ((str.length() > 0) && (str[0] == ch));
        }
    };
    bind2nd(startsWithChar(), 'A')