namespace cpp

C++ lernen, kennen, anwenden

Benutzer-Werkzeuge

Webseiten-Werkzeuge


kennen:include:string

Unterschiede

Hier werden die Unterschiede zwischen zwei Versionen angezeigt.

Link zu dieser Vergleichsansicht

kennen:include:string [2013-03-17 11:14] (aktuell)
Zeile 1: Zeile 1:
 +====== <​string>​ ======
 +===== Zeichenkettenklasse std::string =====
 +Die Zeichenkettenklasse ''​std::​string''​ für ''​char'' ​
 +bzw. ''​std::​wstring''​ für ''​wchar_t''​
 +setzt den Programmierer von fehlerträchtigen Routineaufgaben frei.
 +Die Speicherverwaltung erfolgt automatisch.
 +Die ''​std::​string''​-Klasse besitzt neben [[#​Konstruktoren]]
 + ​Methoden zum
 +[[#​Zuweisen]],​
 +[[#​Anhängen]],​
 +[[#​Einfügen]],​
 +[[#​Löschen]],​
 +[[#​Ersetzen]],​
 +[[#​Suchen]],​
 +[[#​Vergleichen]],​
 +für [[#Ein- und Ausgabe]],
 +[[#​Zeichenzugriff]],​
 +[[#​Vertauschen]],​
 +[[#​size|Größenabfrage]]
 +und den Zugriff auf [[#​Teilzeichenketten]]
 +und [[#​C-Zeichenketten]].
 +Zur Beschreibung der umfangreichen Klassenschnittstelle werden
 +folgende Parameternamen benutzt:
  
 +<code cpp>
 +std::​string ​           s;
 +const std::​string& ​    str;
 +const char*            ptr;
 +char                   c;
 +std::​string::​size_type pos, n, pos2, n2;
 +std::​string::​iterator ​ first, last, first2, last2;
 +</​code>​
 +
 +==== Konstruktoren ====
 +Konstruktoren schaffen einen neuen ''​std::​string''​ aus
 +
 +
 +| ''​std::​string(str,​ pos=0, n=pos)''​ | ''​str''​ ab ''​str[pos]''​ mit max. n Zeichen|
 +| ''​std::​string(ptr)''​ | einer C-Zeichenkette|
 +| ''​std::​string(ptr,​ n)''​ | mit bis zu ''​n''​ Zeichen oder bis zur Ende-Null|
 +| ''​std::​string(n,​ c)''​ | ''​n''​ Zeichen ''​c''​|
 +| ''​std::​string(first,​ last)''​ | einem Iterator-Bereich [first,​last)|
 +<code cpp>
 +char* ptr = "​Hello,​ world of strings!";​
 +std::string s1;             // leer
 +std::string s2 = ptr;
 +std::string s3(ptr); ​       // Kopie
 +std::string s4(s2, 7);      // "world of strings!" ​
 +std::string s5(s2, 7, 5);   // "​world"​
 +std::string s6(5, '​*'​); ​    // "​*****"​
 +std::string s7(ptr, ptr+5); // "​Hello"​
 +</​code>​
 +
 +==== Zuweisen ====
 +Zuweisungen mit ''​=''​ oder der ''​assign()''​-Methode weisen einem existierenden ''​std::​string''​
 +
 +| ''​assign(str,​ pos=0, n=pos)''​ | ''​str''​ ab ''​str[pos]''​ mit max. n Zeichen|
 +| ''​assign(ptr)''​ | eine C-Zeichenkette|
 +| ''​assign(ptr,​ n)''​ | mit bis zu ''​n''​ Zeichen oder bis zur Ende-Null|
 +| ''​assign(n,​ c)''​ | ''​n''​ Zeichen ''​c''​|
 +| ''​assign(first,​ last)''​ | einem Iterator-Bereich [first,​last) zu|
 +<code cpp>
 +s = ptr;
 +s = '​C';​
 +s.assign(5,'​*'​);​
 +s.assign(ptr,​ ptr+5);
 +</​code>​
 +
 +==== Anhängen ====
 +Verknüpfungen (Anhängen) können mit mit Operatoren ''​+''​ und ''​+=''​ erfolgen:
 +
 +<code cpp>
 +s += str; // s = s + str;
 +s += ptr; //     s + ptr
 +s += c;   // ​    s + c
 +</​code>​
 +Die ''​append()''​-Methoden hängen an einen existierenden ''​string'' ​
 +
 +| ''​append(str,​ pos=0, n=pos)''​ | ''​str''​ ab ''​str[pos]''​ mit max. n Zeichen|
 +| ''​append(ptr)''​ | eine C-Zeichenkette|
 +| ''​append(ptr,​ n)''​ | mit bis zu ''​n''​ Zeichen oder bis zur Ende-Null|
 +| ''​append(n,​ c)''​ | ''​n''​ Zeichen ''​c''​|
 +| ''​append(first,​ last)''​ | einen Iterator-Bereich [first,​last) an|
 +
 +==== Einfügen ====
 +Einfügungen schieben vor ''​pos''​
 +bzw. vor den Iterator ''​iter_pos''​
 +
 +| ''​insert(pos,​ str, pos2=0, n=npos)''​ | ''​str''​ ab ''​str[pos2]''​ mit max. n Zeichen|
 +| ''​insert(pos,​ ptr)''​ | eine C-Zeichenkette|
 +| ''​insert(pos,​ ptr, n)''​ | mit bis zu ''​n''​ Zeichen oder bis zur Ende-Null|
 +| ''​insert(pos,​ n, c)''​ | ''​n''​ Zeichen ''​c''​|
 +| ''​insert(iter_pos,​ c, ='​\0'​)''​ | ein Zeichen ''​c''​|
 +| ''​insert(iter_pos,​ n, c)''​ | ''​n''​ Zeichen ''​c''​|
 +| ''​insert(iter_pos,​ first, last)''​ | einen Iterator-Bereich [first,​last) ein|
 +<code cpp>
 +s = immer;
 +s.insert(0, "​Mann-o-mann",​ 0, 3);
 +s.insert(3,​1,'​ ');
 +s.insert(s.end(),​ " noch was ");
 +cout << s.insert(s.size(),​ "​einfuegen."​) << endl;
 +</​code>​
 +
 +==== Löschen ====
 +Löschmethoden entfernen
 +
 +| ''​erase(pos=0,​ n=pos)''​ | ab ''​s[pos]''​ maximal n Zeichen|
 +| ''​erase(iter_pos)''​ | das Zeichen ''​*iter_pos''​|
 +| ''​erase(first,​ last)''​ | den Iterator-Bereich [first,​last)|
 +<code cpp>
 +s = "Alles Überflüssige wird unverzüglich gelöscht.";​
 +s.erase(s.end()-1); ​             // Satzpunkt weg  ​
 +s.erase(s.begin()+6,​ s.end()-9); // "​Alles ​ gelöscht";​
 +s.erase(5,​2); ​                   // "​Allesgelöscht";  ​
 +</​code>​
 +
 +==== Ersetzen ====
 +Ersetzen lassen sich ''​n''​ Zeichen ab ''​pos'' ​
 +oder der Iteratorbereich (first,​last) durch
 +
 +| ''​replace(pos,​ n, str, pos2=0, n2=npos)''​ | ''​str''​ ab ''​str[pos2]''​ mit max. n2 Zeichen|
 +| ''​replace(pos,​ n, ptr)''​ | eine C-Zeichenkette|
 +| ''​replace(pos,​ n, ptr, n2)''​ | mit bis zu ''​n2''​ Zeichen oder bis zur Ende-Null|
 +| ''​replace(pos,​ n, n2, c)''​ | ''​n2''​ Zeichen ''​c''​|
 +| ''​replace(first,​ last, str)''​ | ''​str''​|
 +| ''​replace(first,​ last, ptr)''​ | eine C-Zeichenkette|
 +| ''​replace(first,​ last, ptr, n2)''​ | mit bis zu ''​n2''​ Zeichen oder bis zur Ende-Null|
 +| ''​replace(first,​ last, n2, c)''​ | ''​n2''​ Zeichen ''​c''​|
 +| ''​replace(first,​ last, first2, last2)''​ | den Iterator-Bereich [first2,​last2)|
 +<code cpp>
 +std::string s1 = "Das funktioniert nur dann, wenn du fest dran glaubst.";​
 +std::string s2 = "​nicht";​
 +s1.replace(s1.find("​nur dann"​),​ 8, s2);    // wird länger
 +s1.replace(s1.find("​fest"​),​ 4, s2);        // wird kürzer  ​
 +s1.replace(s1.end()-1,​ s1.end(), 10, '​.'​); ​
 +</​code>​
 +
 +==== Suchen ====
 +Suchmethoden suchen ab ''​s[pos]''​ in den folgenden maximal ''​n''​ Zeichen
 +einen Teilstring, eine C-Zeichenkette oder ein Zeichen
 +
 +| von vorn | von hinten|
 +| ''​find(str,​ pos=0)'' ​ | ''​rfind(str,​ pos=npos)''​|
 +| ''​find(ptr,​ pos, n)''​ | ''​rfind(ptr,​ pos, n)''​|
 +| ''​find(ptr,​ pos=0)'' ​ | ''​rfind(ptr,​ pos=npos)''​|
 +| ''​find(c,​ pos=0)'' ​   | ''​rfind(c,​ pos=npos)''​|
 +| ||
 +| die erste Übereinstimmung | die letzte Übereinstimmung|
 +| ''​find_first_of(str,​ pos=0)'' ​ | ''​find_last_of(str,​ pos=npos)''​|
 +| ''​find_first_of(ptr,​ pos, n)''​ | ''​find_last_of(ptr,​ pos, n)''​|
 +| ''​find_first_of(ptr,​ pos=0)'' ​ | ''​find_last_of(ptr,​ pos=npos)''​|
 +| ''​find_first_of(c,​ pos=0)'' ​   | ''​find_last_of(c,​ pos=npos)''​|
 +| | |
 +| die erste Nichtübereinstimmung | die letzte Nichtübereinstimmung|
 +| ''​find_first_not_of(str,​ pos=0)'' ​ | ''​find_last_not_of(str,​ pos=npos)''​|
 +| ''​find_first_not_of(ptr,​ pos, n)''​ | ''​find_last_not_of(ptr,​ pos, n)''​|
 +| ''​find_first_not_of(ptr,​ pos=0)'' ​ | ''​find_last_not_of(ptr,​ pos=npos)''​|
 +| ''​find_first_not_of(c,​ pos=0)'' ​   | ''​find_last_not_of(c,​ pos=npos)''​|
 +
 +Sie liefern den Anfangsindex der gefundenen Kette bzw. des Zeichens, ​
 +auf das die geforderte Bedingung zutrifft.
 +Bei fehlgeschlagener Suche wird die Konstante ''​std::​string::​npos''​ geliefert.
 +
 +<code cpp>
 +std::string s = "​Entente cordial";​
 +std::string NT = "​nt";​
 +std::string vokale = "​AEIOUaeiou";​
 +
 +pos = s.find(NT); ​                 // 1
 +pos = s.rfind(NT); ​                // 4
 +pos = s.find_first_of(vokale); ​    // 3
 +pos = s.find_last_of (vokale); ​    // 13
 +pos = s.find_first_not_of(vokale);​ // 1
 +pos = s.find_last_not_of (vokale); // 14
 +
 +if (pos != std::​string::​npos)
 +{
 +  std::cout << "​letzter Konsonant: " << s[pos] << '​\n'​
 +            << s << '​\n'​
 +            << std::​string(pos,​ ' ') << "​^\n";​
 +}
 +</​code>​
 +
 +==== Vergleichen ====
 +Vergleiche mit den Operatoren ''​== != < <= >= >''​ sind auch mit C-Zeichenketten möglich.
 +
 +<code cpp>
 +std::string s = "​Asterix";​
 +char*     ptr = "​Obelix";​
 +
 +if (name == s || name == ptr)
 +{
 +  std::cout << "Die spinnen, die Roemer!\n";​
 +}
 +</​code>​
 +Die ''​compare()''​-Methoden vergleichen in ''​s'' ​
 +bzw. ab ''​s[pos]''​ maximal ''​n''​ Zeichen mit
 +
 +| ''​compare(str,​ pos2=0, n2)''​ | ''​str[pos2]''​ bis max. ''​str[pos2+n2]''​|
 +| ''​compare(pos,​ n, str, pos2=0, n2=npos)''​ | |
 +| ''​compare(ptr,​ n2)''​ | der C-Zeichenkette|
 +| ''​compare(pos,​ n, ptr, n2=npos)''​ | |
 +Sie liefern
 +  * einen negativen Wert, wenn ''​s''​ lexikographisch vor dem Argument kommt,
 +  * einen positiven Wert, wenn ''​s''​ danach kommt oder
 +  * 0 bei Übereinstimmung.
 +
 +==== Ein- und Ausgabe ====
 +Ein- und Ausgaben erfolgen mit den Stromoperatoren.
 +Eingelesen wird nur ein Wort bis vor das nächste Whitespace-Zeichen,​
 +führende Whitespaces werden dabei übergangen.
 +Die globale Funktion ''​getline()''​ liest dagegen eine ganze Zeile, genauer
 +alle Zeichen bis zum Auftreten des Begrenzers ''​delim''​ ein.
 +Der Begrenzer wird aus dem Strom entfernt, jedoch nicht in die Zeichenkette aufgenommen.
 +
 +<code cpp>
 +std::cin >> s;
 +std::​getline(std::​cin,​ s, '​\n'​);​
 +std::cout << s << '​\n';​
 +</​code>​
 +
 +==== Zeichenzugriff ====
 +Der Zugriff auf einzelne Zeichen erfolgt mit
 +''​s[pos]''​ ungeprüft bzw. ''​s.at(pos)''​ geprüft.
 +Wenn ''​pos''​ hinter dem Ende liegt, wirft ''​at()''​ eine 
 +''​out_of_range''​-Ausnahme.
 +Die ''​std::​string''​-Objekte können als [[..:​stl#​sequentielle Container|sequentielle]] Zeichen-Container
 +aufgefasst und mit [[..:​stl#​Algorithmen]] bearbeitet werden.
 +
 +<code cpp>
 +reverse(s.begin(),​ s.end());
 +</​code>​
 +[[..:​stl#​Iteratoren]] auf den Anfang und hinter das Ende der Zeichenfolge
 +liefern die Methoden
 +
 +| ''​begin()'' ​ | ''​end()'' ​ | vorwärts laufend|
 +| ''​rbegin()''​ | ''​rend()''​ | rückwärts laufend|
 +
 +==== Vertauschen ====
 +Vertauschungen wechseln die Objektwerte aus.
 +
 +<code cpp>
 +std::string s1="​abc",​ s2 = "​def";​
 +s1.swap(s2); ​ // (effizienter) hin
 +std::​swap(s1,​ s2); // und zurück
 +</​code>​
 +
 +Größe und Kapazität sind erfragbar und änderbar.
 +
 +| ''​empty()''​ | liefert ''​true''​ bei Leerstring|
 +| ''​length()''​ | Anzahl Zeichen|
 +| ''​size()''​ | dto.|
 +| ''​max_size()''​ | größtmögliche Zeichenzahl|
 +| ''​capacity()''​ | Fassungsvermögen ohne Reallokation|
 +| ''​reserve(n=0)''​ | reserviert Speicher für ''​n''​ Zeichen|
 +| ''​resize(n,​ c='​\0'​)''​ | kürzt oder füllt mit ''​c''​ auf|
 +| ''​clear()''​ | leert den Inhalt|
 +
 +==== Teilketten und C-Zeichenketten ====
 +Teilzeichenketten und C-Zeichenketten lassen sich herausziehen:​
 +
 +| ''​substr(pos=0,​n=npos)''​ | liefert maximal ''​n''​ Zeichen ab ''​s[pos]''​|
 +| ''​c_str()''​ | liefert temporär gültigen Zeiger auf Zeichenkette|
 +| ''​copy(ptr,​ n, pos=0)''​ | kopiert maximal ''​n''​ Zeichen ab ''​s[pos]''​ nach ''​ptr''​|
 +<code cpp>
 +std::string s  = "​Heiliger Apollo!";​
 +cout << s.substr(9,​5) << endl; // "​Apoll"​
 +</​code>​
 +Die Umwandlung in eine C-Zeichenkette sollte nur erfolgen, wenn dies unumgänglich ist.
 +Der von ''​c_str()''​ gelieferte Zeiger ist nur solange gültig,
 +wie der liefernde ''​string''​ existiert und dessen Inhalt nicht geändert wurde.
 +Die Methode wurde hauptsächlich eingeführt,​
 +weil viele (alte) Bibliotheksfunktionen einen ''​const char*''​ erwarten.
 +Bei ''​copy()''​ muss das Feld ''​ptr[]''​ genügend lang sein, 
 +von ''​copy()''​ wird keine Ende-Null geschrieben.
 +
 +<code cpp>
 +char ptr[80];
 +std::​string::​size_type anzahl = s.copy(ptr, 79); // Zahl kopierter Zeichen
 +ptr[anzahl] = '​\0'; ​                             // manuell anfügen!
 +</​code>​
 +===== Funktionen =====
 +<code cpp>
 +std::​istream&​ getline (std::​istream&​ in, std::​string&​ s, char begrenzer = '​\n'​); ​
 +</​code>​
 +[[..:​lib:​getline|Beschreibung]]:​
 + Liest aus dem Datenstrom die Zeichenfolge bis vor den begrenzer. Der Begrenzer wird aus dem Datenstrom entfernt.
 +
 +<code cpp>
 +std::string to_string (long long zahl); ​
 +std::string to_string (unsigned long long zahl); ​
 +std::string to_string (double zahl); ​
 +</​code>​
 +[[..:​lib:​to_string|Beschreibung]]:​
 + ​Konvertiert Zahl in Zeichenkette.
 +
 +<code cpp>
 +int                stoi   ​(const std::​string&​ s, size_t *pos = 0, int base = 10);
 +long               ​stol ​  ​(const std::​string&​ s, size_t *pos = 0, int base = 10);
 +long long          stoll  (const std::​string&​ s, size_t *pos = 0, int base = 10);
 +unsigned long      stoul  (const std::​string&​ s, size_t *pos = 0, int base = 10);
 +unsigned long long stoull (const std::​string&​ s, size_t *pos = 0, int base = 10);
 +</​code>​
 +[[..:​lib:​stoi|Beschreibung]]:​
 + ​Konvertiert Zeichenkette in Ganzzahl.
 +
 +<code cpp>
 +float       ​stof ​ (const std::​string&​ s, size_t *pos = 0);
 +double ​     stod  (const std::​string&​ s, size_t *pos = 0);
 +long double stold (const std::​string&​ s, size_t *pos = 0);
 +</​code>​
 +[[..:​lib:​stod|Beschreibung]]:​
 + ​Konvertiert Zeichenkette in Gleitkommazahl.
 +
 +Für MinGW 4.7.x ist ein [[http://​tehsausage.com/​mingw-to-string|inoffizieller Patch]] zur Nutzung der string-Konversionen verfügbar. ​
kennen/include/string.txt · Zuletzt geändert: 2013-03-17 11:14 (Externe Bearbeitung)