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')
