Strings em C++: noções de std::string, métodos e armadilhas

std::string: texto que se gerencia sozinho

Na página anterior você viu como ponteiros inteligentes permitem que um objeto seja dono de um recurso e o libere automaticamente. std::string é essa mesma ideia aplicada ao texto: ela possui um buffer de caracteres, faz ele crescer quando você anexa algo e o libera quando a string sai de escopo. Você nunca chama new, nunca conta bytes e nunca se preocupa com um terminador nulo faltando.

Para usá-la, inclua <string>. A classe fica no espaço de nomes 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;
}

Esse operador + faz trabalho de verdade - ele aloca um buffer novo grande o suficiente para as duas partes e as copia para dentro. Com um char* cru você teria que recorrer a strcpy e strcat e torcer para que seu buffer fosse grande o bastante. std::string faz toda essa classe de erros desaparecer.

Montando e juntando strings

Você pode concatenar com +, mas o cavalo de batalha para fazer uma string crescer no lugar é +=. Ele anexa ao buffer existente em vez de produzir uma string totalmente nova a cada vez, o que faz diferença dentro de laços.

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

int main() {
    string sentence;                  // começa vazia
    string words[] = {"the", "quick", "brown", "fox"};

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

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

Uma surpresa comum: + exige que pelo menos um dos operandos já seja um std::string. Dois literais de string são apenas const char*, então "a" + "b" não compila - não existe um operator+ para dois ponteiros crus. Transforme um deles em string primeiro:

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

Repare que essa última forma usa o sufixo s de <string> (using namespace std::string_literals;), que transforma um literal diretamente em um std::string.

Acessando o interior de uma string

Um std::string se comporta como um contêiner de char, então você pode indexá-lo, percorrê-lo e pedir pedaços dele.

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

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

    cout << word[0] << "\n";          // h  - indexação com []
    cout << word.front() << " " << word.back() << "\n";  // h o
    cout << word.substr(1, 3) << "\n"; // ell - 3 caracteres a partir do índice 1

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

substr(pos, len) retorna uma string totalmente nova copiada do original; ela não modifica a fonte. Cuidado com os limites: word[10] em uma string de 5 caracteres é comportamento indefinido - não vai lançar nada, apenas lê lixo. Se quiser um acesso verificado que lança std::out_of_range, use word.at(10) em vez de word[10].

Outra armadilha clássica: .size() retorna um tipo sem sinal (size_t). Escrever um laço de trás para frente como for (size_t i = word.size() - 1; i >= 0; --i) nunca termina, porque um i sem sinal nunca pode ficar abaixo de zero - ele dá a volta e vira um número enorme. Use um índice com sinal ou reestruture a condição quando precisar percorrer uma string ao contrário.

Buscando e substituindo

find localiza uma substring ou caractere e retorna o índice inicial. Quando o alvo não está presente, ele retorna a constante especial std::string::npos - sempre compare com ela em vez de presumir que find retorna -1.

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

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

    size_t dot = path.find('.');               // 6 - primeiro ponto
    size_t lastDot = path.rfind('.');          // 12 - último ponto

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

Para mudar texto no lugar, replace(pos, len, text) troca um trecho por conteúdo novo (que pode ter outro tamanho), e insert/erase adicionam ou removem pedaços:

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

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

    msg.replace(7, 4, "dogs");   // substitui 4 caracteres no índice 7
    cout << msg << "\n";          // I like dogs

    msg.insert(0, "Honestly, "); // adiciona no início
    cout << msg << "\n";          // Honestly, I like dogs

    msg.erase(0, 10);            // remove os primeiros 10 caracteres
    cout << msg << "\n";          // I like dogs
    return 0;
}

Strings e números

Texto e números não se convertem sozinhos - "42" são três caracteres, não o inteiro 42. A biblioteca padrão oferece funções de conversão nos dois sentidos. Use stoi, stod e companhia para analisar texto e transformá-lo em números, e to_string para ir na direção oposta.

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

Duas armadilhas aqui. Primeira, stoi("abc") lança std::invalid_argument, então proteja entrada não confiável com try/catch. Segunda, to_string(3.99) dá o 3.990000 completo - se você precisa de controle sobre precisão e formatação, isso é trabalho para string streams, que é exatamente para onde vamos a seguir.

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

A seguir: entrada e saída

Você vem imprimindo strings com cout esse tempo todo, mas lê-las de volta a partir do usuário tem suas próprias surpresas - cin >> name para no primeiro espaço, então uma linha inteira como "Ada Lovelace" precisa de std::getline. A próxima página cobre a entrada e saída em C++ como deve ser: operadores de stream, ler linhas inteiras e misturar >> com getline sem tropeçar em quebras de linha que sobraram.