Unterschiede

Hier werden die Unterschiede zwischen zwei Versionen angezeigt.

@@ 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>
+Ob eine Teilzeichenkette enthalten ist, erkannt man ab C++23 einfacher mit ''s.contains(str)''.
+==== 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.