Stringi w C++: podstawy std::string, metody i pułapki

std::string: tekst, który sam sobą zarządza

Na poprzedniej stronie widać było, jak inteligentne wskaźniki pozwalają obiektowi posiadać zasób i automatycznie po nim sprzątać. std::string to ta sama idea zastosowana do tekstu: posiada bufor znaków, powiększa go, gdy dopisujesz, i zwalnia, gdy napis wychodzi z zasięgu. Nigdy nie wywołujesz new, nie liczysz bajtów i nie martwisz się o brakujący terminator null.

Aby go użyć, dołącz <string>. Klasa należy do przestrzeni nazw 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;
}

Operator + wykonuje tu prawdziwą pracę: alokuje nowy bufor wystarczająco duży na oba kawałki i kopiuje je do niego. Przy surowym char*, czyli zwykłym wskaźniku do bufora znaków, trzeba by sięgać po strcpy i strcat z nadzieją, że bufor jest wystarczająco duży. std::string sprawia, że cała ta klasa błędów znika.

Budowanie i łączenie napisów

Łączyć można przez +, ale podstawowym narzędziem do powiększania napisu w miejscu jest +=. Dopisuje do istniejącego bufora, zamiast za każdym razem tworzyć zupełnie nowy napis, co ma znaczenie w pętlach.

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

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

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

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

Częste zaskoczenie: + wymaga, żeby przynajmniej jeden operand już był std::string. Dwa literały tekstowe to tylko const char*, więc "a" + "b" się nie kompiluje: nie ma operator+ dla dwóch surowych wskaźników. Najpierw zrób z jednego z nich 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

Ostatnia forma używa przyrostka s z <string> (using namespace std::string_literals;), który zamienia literał bezpośrednio w std::string.

Sięganie do wnętrza napisu

std::string zachowuje się jak kontener char, więc możesz go indeksować, przechodzić po nim pętlą i prosić o jego fragmenty.

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

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

    cout << word[0] << "\n";          // h: indeksowanie przez []
    cout << word.front() << " " << word.back() << "\n";  // h o
    cout << word.substr(1, 3) << "\n"; // ell: 3 znaki od indeksu 1

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

substr(pos, len) zwraca zupełnie nowy napis skopiowany z oryginału; nie zmienia źródła. Uważaj na granice: word[10] na napisie o 5 znakach to niezdefiniowane zachowanie: nie rzuci wyjątku, tylko przeczyta śmieci. Jeśli chcesz dostępu ze sprawdzaniem, który rzuca std::out_of_range, użyj word.at(10) zamiast word[10].

Kolejna klasyczna pułapka: .size() zwraca typ bez znaku (size_t). Pętla wsteczna w rodzaju for (size_t i = word.size() - 1; i >= 0; --i) nigdy się nie kończy, bo i bez znaku nigdy nie spadnie poniżej zera, tylko przekręci się do ogromnej liczby. Gdy musisz przejść napis od końca, użyj indeksu ze znakiem albo przebuduj warunek.

Wyszukiwanie i zamiana

find odnajduje podnapis albo znak i zwraca indeks początku. Gdy szukanego elementu nie ma, zwraca specjalną stałą std::string::npos: zawsze porównuj z nią, zamiast zakładać, że find zwraca -1.

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

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

    size_t dot = path.find('.');               // 6: pierwsza kropka
    size_t lastDot = path.rfind('.');          // 12: ostatnia kropka

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

Aby zmienić tekst w miejscu, replace(pos, len, text) zamienia fragment na nową treść (która może mieć inną długość), a insert/erase dodają albo usuwają kawałki:

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

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

    msg.replace(7, 4, "dogs");   // zamień 4 znaki od indeksu 7
    cout << msg << "\n";          // I like dogs

    msg.insert(0, "Honestly, "); // dodaj na początku
    cout << msg << "\n";          // Honestly, I like dogs

    msg.erase(0, 10);            // usuń pierwsze 10 znaków
    cout << msg << "\n";          // I like dogs
    return 0;
}

Napisy i liczby

Tekst i liczby nie konwertują się same: "42" to trzy znaki, a nie liczba całkowita 42. Biblioteka standardowa daje funkcje konwersji w obie strony. Używaj stoi, stod i pokrewnych do parsowania tekstu na liczby, a to_string do konwersji w drugą stronę.

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

Są tu dwie pułapki. Po pierwsze stoi("abc") rzuca std::invalid_argument, więc niezaufane dane zabezpieczaj blokiem try/catch. Po drugie to_string(3.99) daje pełne 3.990000: jeśli potrzebujesz kontroli nad precyzją i formatowaniem, to zadanie dla strumieni napisów, do których właśnie zmierzamy.

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

Dalej: wejście i wyjście

Napisy wypisujesz przez cout od samego początku, ale wczytywanie ich od użytkownika ma własne niespodzianki: cin >> name zatrzymuje się na pierwszej spacji, więc cała linia, taka jak „Ada Lovelace”, wymaga zamiast tego std::getline. Następna strona porządnie omawia wejście i wyjście w C++: operatory strumieni, wczytywanie całych linii i łączenie >> z getline bez potykania się o pozostałe znaki nowej linii.