<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, Größenabfrage und den Zugriff auf Teilzeichenketten und C-Zeichenketten. Zur Beschreibung der umfangreichen Klassenschnittstelle werden folgende Parameternamen benutzt:

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;

Konstruktoren schaffen einen neuen std::string aus

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"

Zuweisungen mit = oder der assign()-Methode weisen einem existierenden std::string

s = ptr;
s = 'C';
s.assign(5,'*');
s.assign(ptr, ptr+5);

Verknüpfungen (Anhängen) können mit mit Operatoren + und += erfolgen:

s += str; // s = s + str;
s += ptr; //     s + ptr
s += c;   //     s + c

Die append()-Methoden hängen an einen existierenden string

Einfügungen schieben vor pos bzw. vor den Iterator iter_pos

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;

Löschmethoden entfernen

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";  

Ersetzen lassen sich n Zeichen ab pos oder der Iteratorbereich (first,last) durch

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, '.'); 

Suchmethoden suchen ab s[pos] in den folgenden maximal n Zeichen einen Teilstring, eine C-Zeichenkette oder ein Zeichen

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.

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";
}

Ob eine Teilzeichenkette enthalten ist, erkannt man ab C++23 einfacher mit s.contains(str).

Vergleiche mit den Operatoren == != < ⇐ >= > sind auch mit C-Zeichenketten möglich.

std::string s = "Asterix";
char*     ptr = "Obelix";
 
if (name == s || name == ptr)
{
  std::cout << "Die spinnen, die Roemer!\n";
}

Die compare()-Methoden vergleichen in s bzw. ab s[pos] maximal n Zeichen mit

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 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.

std::cin >> s;
std::getline(std::cin, s, '\n');
std::cout << s << '\n';

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 sequentielle Zeichen-Container aufgefasst und mit Algorithmen bearbeitet werden.

reverse(s.begin(), s.end());

Iteratoren auf den Anfang und hinter das Ende der Zeichenfolge liefern die Methoden

Vertauschungen wechseln die Objektwerte aus.

std::string s1="abc", s2 = "def";
s1.swap(s2);  // (effizienter) hin
std::swap(s1, s2); // und zurück

Größe und Kapazität sind erfragbar und änderbar.

Teilzeichenketten und C-Zeichenketten lassen sich herausziehen:

std::string s  = "Heiliger Apollo!";
cout << s.substr(9,5) << endl; // "Apoll"

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.

char ptr[80];
std::string::size_type anzahl = s.copy(ptr, 79); // Zahl kopierter Zeichen
ptr[anzahl] = '\0';                              // manuell anfügen!

std::istream& getline (std::istream& in, std::string& s, char begrenzer = '\n'); 

Beschreibung: Liest aus dem Datenstrom die Zeichenfolge bis vor den begrenzer. Der Begrenzer wird aus dem Datenstrom entfernt.

std::string to_string (long long zahl); 
std::string to_string (unsigned long long zahl); 
std::string to_string (double zahl); 

Beschreibung: Konvertiert Zahl in Zeichenkette.

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

Beschreibung: Konvertiert Zeichenkette in Ganzzahl.

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

Beschreibung: Konvertiert Zeichenkette in Gleitkommazahl.