C++-Strings: std::string-Grundlagen, Methoden und Stolperfallen

std::string: Text, der sich selbst verwaltet

Auf der vorherigen Seite hast du gesehen, wie Smart Pointer einem Objekt erlauben, eine Ressource zu besitzen und sie automatisch aufzuräumen. std::string ist dieselbe Idee, angewendet auf Text: Er besitzt einen Puffer aus Zeichen, vergrößert ihn beim Anhängen und gibt ihn frei, wenn der String den Gültigkeitsbereich verlässt. Du rufst nie new auf, zählst nie Bytes und sorgst dich nie um einen fehlenden Nullterminator.

Um ihn zu verwenden, binde <string> ein. Die Klasse liegt im Namensraum std.

#include <iostream>
#include <string>
using namespace std;

int main() {
    string name = "Ada";
    string greeting = "Hello, " + name + "!";

    cout << greeting << "\n";          // Hello, Ada!
    cout << "Length: " << name.size() << "\n";  // 3
    return 0;
}

Dieser +-Operator leistet echte Arbeit - er reserviert einen neuen Puffer, der groß genug für beide Teile ist, und kopiert sie hinein. Bei einem rohen char* müsstest du zu strcpy und strcat greifen und hoffen, dass dein Puffer groß genug ist. std::string lässt diese ganze Fehlerklasse verschwinden.

Strings aufbauen und zusammenfügen

Du kannst mit + verketten, aber das Arbeitspferd, um einen String an Ort und Stelle wachsen zu lassen, ist +=. Es hängt an den bestehenden Puffer an, statt jedes Mal einen brandneuen String zu erzeugen - das ist innerhalb von Schleifen wichtig.

#include <iostream>
#include <string>
using namespace std;

int main() {
    string sentence;                  // beginnt leer
    string words[] = {"the", "quick", "brown", "fox"};

    for (const string& w : words) {
        sentence += w;
        sentence += " ";
    }

    cout << sentence << "\n";         // the quick brown fox
    return 0;
}

Eine häufige Überraschung: + braucht mindestens einen Operanden, der bereits ein std::string ist. Zwei String-Literale sind nur const char*, daher kompiliert "a" + "b" nicht - es gibt keinen operator+ für zwei rohe Zeiger. Mach zuerst einen davon zu einem String:

string s = "a" + "b";              // error: can't add two const char*
string s = string("a") + "b";      // fine - left side is a std::string
string s = "a"s + "b";             // fine in C++14+, the "s" literal suffix

Beachte, dass die letzte Form das s-Suffix aus <string> verwendet (using namespace std::string_literals;), das ein Literal direkt in einen std::string verwandelt.

In einen String hineingreifen

Ein std::string verhält sich wie ein Container aus char, du kannst ihn also indizieren, durchlaufen und nach Teilstücken fragen.

#include <iostream>
#include <string>
using namespace std;

int main() {
    string word = "hello";

    cout << word[0] << "\n";          // h  - Indizierung mit []
    cout << word.front() << " " << word.back() << "\n";  // h o
    cout << word.substr(1, 3) << "\n"; // ell - 3 Zeichen ab Index 1

    for (char c : word) {
        cout << c << '-';             // h-e-l-l-o-
    }
    cout << "\n";
    return 0;
}

substr(pos, len) liefert einen brandneuen String, der aus dem Original kopiert wurde; es verändert die Quelle nicht. Achte auf die Grenzen: word[10] auf einem 5-Zeichen-String ist undefiniertes Verhalten - es wirft nichts, es liest einfach Datenmüll. Wenn du einen geprüften Zugriff willst, der std::out_of_range wirft, verwende word.at(10) statt word[10].

Eine weitere klassische Falle: .size() liefert einen vorzeichenlosen Typ (size_t). Eine rückwärts laufende Schleife wie for (size_t i = word.size() - 1; i >= 0; --i) endet nie, denn ein vorzeichenloses i kann nie unter null fallen - es läuft über und wird zu einer riesigen Zahl. Verwende einen vorzeichenbehafteten Index oder strukturiere die Bedingung um, wenn du einen String rückwärts durchlaufen musst.

Suchen und Ersetzen

find findet einen Teilstring oder ein Zeichen und liefert den Startindex. Ist das Ziel nicht vorhanden, liefert es die spezielle Konstante std::string::npos - vergleiche immer damit, statt anzunehmen, dass find -1 liefert.

#include <iostream>
#include <string>
using namespace std;

int main() {
    string path = "report.final.pdf";

    size_t dot = path.find('.');               // 6 - erster Punkt
    size_t lastDot = path.rfind('.');          // 12 - letzter Punkt

    if (lastDot != string::npos) {
        cout << "Extension: " << path.substr(lastDot + 1) << "\n"; // pdf
        cout << "Base: " << path.substr(0, lastDot) << "\n";       // report.final
    }
    return 0;
}

Um Text an Ort und Stelle zu ändern, tauscht replace(pos, len, text) einen Abschnitt gegen neuen Inhalt (der eine andere Länge haben kann), und insert/erase fügen Stücke hinzu oder entfernen sie:

#include <iostream>
#include <string>
using namespace std;

int main() {
    string msg = "I like cats";

    msg.replace(7, 4, "dogs");   // ersetzt 4 Zeichen ab Index 7
    cout << msg << "\n";          // I like dogs

    msg.insert(0, "Honestly, "); // am Anfang hinzufügen
    cout << msg << "\n";          // Honestly, I like dogs

    msg.erase(0, 10);            // die ersten 10 Zeichen entfernen
    cout << msg << "\n";          // I like dogs
    return 0;
}

Strings und Zahlen

Text und Zahlen wandeln sich nicht von selbst um - "42" sind drei Zeichen, nicht die Ganzzahl 42. Die Standardbibliothek gibt dir Umwandlungsfunktionen in beide Richtungen. Verwende stoi, stod und Co., um Text in Zahlen zu parsen, und to_string für die andere Richtung.

#include <iostream>
#include <string>
using namespace std;

int main() {
    string countText = "42";
    int count = stoi(countText) + 8;     // 50

    double price = 3.99;
    string label = "Price: $" + to_string(price);

    cout << count << "\n";               // 50
    cout << label << "\n";               // Price: $3.990000
    return 0;
}

Zwei Stolperfallen hier. Erstens wirft stoi("abc") std::invalid_argument, also sichere nicht vertrauenswürdige Eingaben mit try/catch ab. Zweitens liefert to_string(3.99) das volle 3.990000 - wenn du Kontrolle über Genauigkeit und Formatierung brauchst, ist das eine Aufgabe für String-Streams, und genau dorthin geht es als Nächstes.

try {
    int n = std::stoi(userInput);
} catch (const std::invalid_argument&) {
    std::cout << "That wasn't a number.\n";
}

Als Nächstes: Eingabe und Ausgabe

Du hast die ganze Zeit Strings mit cout ausgegeben, aber sie vom Benutzer zurückzulesen hat seine eigenen Überraschungen - cin >> name stoppt beim ersten Leerzeichen, daher braucht eine ganze Zeile wie "Ada Lovelace" stattdessen std::getline. Die nächste Seite behandelt Ein- und Ausgabe in C++ richtig: Stream-Operatoren, das Lesen ganzer Zeilen und das Mischen von >> mit getline, ohne über übrig gebliebene Zeilenumbrüche zu stolpern.