C++ std::string

Os métodos de std::string e as funções livres que trabalham com texto, agrupados pelo que fazem. Cada linha tem a assinatura simplificada, uma explicação curta, um exemplo e o resultado real: todos os 82 exemplos foram compilados juntos e executados com o g++ 15.2 (-std=c++23) na máquina da Ana. Para aprender com calma, veja as aulas Strings, Funções de String e Texto ↔ Número.

Como ler as tabelas
  • Em todos os exemplos, s começa como std::string s = "banana";, a não ser que a célula mostre outra declaração. Cada exemplo começa do zero.
  • Nos métodos que mudam o texto, o resultado mostra como s ficou: s = "bananas".
  • Índices começam em 0: em "banana", o b está na posição 0 e o último a na 5.
  • size_type é std::size_t, um inteiro sem sinal. npos (std::string::npos) é o maior valor dele (18446744073709551615 aqui) e quer dizer "não achei" ou "até o fim".
  • As assinaturas estão simplificadas: a maioria dos métodos também aceita const char*, std::string_view ou um char no lugar de const string&.
  • size() e as posições contam bytes, não letras: um é ocupa 2 (veja Acentos e UTF-8).

Atalhos: Tamanho · Acesso · Modificar · Pedaços · Procurar · Comparar · Texto ↔ número · Funções livres · getline · Por versão

Exemplo rápido

#include <iostream>
#include <string>

int main() {
    std::string s = "banana";
    std::cout << s.size() << '\n';
    std::cout << s.find("na") << '\n';
    std::cout << s.substr(1, 3) << '\n';

    s.replace(0, 1, "C");
    std::cout << s << '\n';

    if (s.find("x") == std::string::npos) {
        std::cout << "não tem x\n";
    }
}
$ g++ -std=c++23 -Wall -Wextra banana.cpp -o banana
$ ./banana
6
2
ana
Canana
não tem x

Experimente: qualquer exemplo das tabelas cabe aqui. Troque as linhas do main e rode.

#include <iostream>
#include <string>

int main() {
    std::string s = "banana";
    std::cout << s.size() << '\n';
    std::cout << s.find("na") << '\n';
    std::cout << s.substr(1, 3) << '\n';

    s.replace(0, 1, "C");
    std::cout << s << '\n';

    if (s.find("x") == std::string::npos) {
        std::cout << "não tem x\n";
    }
}

Tamanho e capacidade

Método ou funçãoO que fazExemploResultado
size_type size() constQuantos bytes (char) o texto tem. Um é em UTF-8 conta 2. Aulas.size()
std::string t = "café";
t.size()
6

5
size_type length() constO mesmo que size(). Aulas.length()6
bool empty() consttrue se o tamanho é 0. Mais claro que size() == 0. Aulas.empty()
std::string{}.empty()
false
true
void clear()Apaga tudo: o texto fica vazio. Aulas.clear()s = ""
void resize(size_type n, char c = '\0')Muda o tamanho: corta o fim ou completa com c. Aulas.resize(3)
s.resize(8, '!')
s = "ban"
s = "banana!!"
size_type capacity() constQuantos bytes cabem sem pedir mais memória. Textos curtos cabem dentro do próprio objeto (15 bytes no g++). Aulas.capacity()15
void reserve(size_type n)Reserva espaço para n bytes de uma vez, antes de muitos +=. Aulas.reserve(100); s.capacity()100

Acessar caracteres

Método ou funçãoO que fazExemploResultado
char& operator[](size_type i)O caractere na posição i (começa em 0). Fora do tamanho: comportamento indefinido, sem aviso. Aulas[0]
s[5]
'b'
'a'
char& at(size_type i)Igual, mas confere: fora do tamanho, lança std::out_of_range. Aulas.at(1)
s.at(10)
'a'
lança std::out_of_range
what(): basic_string::at: __n (which is 10) >= this->size() (which is 6)
char& front() C++11O primeiro caractere (texto não pode estar vazio). Aulas.front()'b'
char& back() C++11O último caractere. Aulas.back()'a'
const char* c_str() constUm ponteiro para o texto terminado em '\0', para funções do C. data() é quase igual. Aulastd::strlen(s.c_str())6

Juntar e modificar

Método ou funçãoO que fazExemploResultado
string& operator+=(…)Acrescenta no fim um texto, um char ou outra string. Aulas += "s"
s += '!'
s = "bananas"
s = "banana!"
string operator+(a, b)Junta dois textos num novo. Um dos lados precisa ser std::string: "a" + "b" não compila. Aulas + " madura""banana madura"
string& append(const string& t)Acrescenta t no fim (como +=). Aulas.append("da")s = "bananada"
string& append(size_type n, char c)Acrescenta n cópias de c. Aulas.append(3, '!')s = "banana!!!"
void push_back(char c)Acrescenta um caractere. Aulas.push_back('s')s = "bananas"
void pop_back() C++11Tira o último caractere. Aulas.pop_back()s = "banan"
string& insert(size_type pos, const string& t)Insere t antes da posição pos. Aulas.insert(0, "uma ")
s.insert(3, "-")
s = "uma banana"
s = "ban-ana"
string& erase(size_type pos = 0, size_type n = npos)Apaga n caracteres a partir de pos; sem n, até o fim. Aulas.erase(1, 2)
s.erase(3)
s = "bana"
s = "ban"
string& replace(size_type pos, size_type n, const string& t)Troca n caracteres a partir de pos por t (de qualquer tamanho). Aulas.replace(0, 1, "C")
s.replace(2, 4, "")
s = "Canana"
s = "ba"
string& assign(size_type n, char c)Substitui o conteúdo por n cópias de c. Também aceita um texto: s.assign("oi"). Aulas.assign(3, 'z')s = "zzz"
void swap(string& t)Troca o conteúdo de duas strings (rápido: não copia o texto). Aulastd::string s = "banana"; std::string t = "uva";
s.swap(t)

s = "uva"

Pedaços

Método ou funçãoO que fazExemploResultado
string substr(size_type pos = 0, size_type n = npos) constUma cópia de n caracteres a partir de pos (atenção: o segundo número é o tamanho, não a posição final). pos além do tamanho: std::out_of_range. Aulas.substr(2)
s.substr(1, 3)
s.substr(4, 100)
s.substr(7)
"nana"
"ana"
"na"
lança std::out_of_range
what(): basic_string::substr: __pos (which is 7) > this->size() (which is 6)
substr(início, tamanho), não (início, fim)

Quem vem de Java, JavaScript ou Python espera que o segundo número seja a posição final. Em C++ é o tamanho do pedaço: s.substr(1, 3) são 3 caracteres a partir da posição 1. Tamanho além do fim não é erro (pega até onde der); início além do fim é.

Procurar

Método ou funçãoO que fazExemploResultado
size_type find(const string& t, size_type pos = 0) constPosição da primeira ocorrência de t a partir de pos, ou npos se não achar. Aulas.find("na")
s.find("na", 3)
s.find("x")
2
4
npos
size_type find(char c, size_type pos = 0) constO mesmo para um caractere. Aulas.find('a')1
size_type rfind(const string& t) constA última ocorrência. Aulas.rfind("na")
s.rfind('a')
4
5
size_type find_first_of(const string& cs) constPrimeira posição de qualquer um dos caracteres de cs. Aulas.find_first_of("nb")
std::string t = "Ana;Bia,Caio";
t.find_first_of(",;")
0

3
size_type find_last_of(const string& cs) constÚltima posição de qualquer um dos caracteres. Aulastd::string t = "/home/ana/notas.txt";
t.find_last_of("/")

9
size_type find_first_not_of(const string& cs) constPrimeira posição de um caractere que não está em cs. Bom para pular espaços. Aulastd::string t = " oi ";
t.find_first_not_of(" ")

3
size_type find_last_not_of(const string& cs) constÚltima posição de um caractere fora de cs. Aulastd::string t = " oi ";
t.find_last_not_of(" ")

4
bool contains(const string& t) const C++23true se t aparece em algum lugar. Aulas.contains("nan")
s.contains('x')
true
false
bool starts_with(const string& t) const C++20Começa com t? Aulas.starts_with("ba")true
bool ends_with(const string& t) const C++20Termina com t? Aulas.ends_with("na")
std::string t = "notas.TXT";
t.ends_with(".txt")
true

false
Sempre compare com npos

find devolve um size_t, nunca −1. Escreva if (s.find("x") != std::string::npos). Um if (s.find("x")) está errado duas vezes: npos é "verdadeiro" e a posição 0, "falso". Se a pergunta é só "tem ou não tem?", use contains (C++23).

Comparar

Método ou funçãoO que fazExemploResultado
== != < <= > >=Comparam o conteúdo, byte a byte (ordem de dicionário pelos códigos: maiúsculas antes das minúsculas, acentuadas depois de tudo). Aulas == "banana"
s < "bala"
std::string("Zebra") < "abacate"
true
false
true
int compare(const string& t) constNegativo se s vem antes, 0 se igual, positivo se vem depois. Aulas.compare("banana")
s.compare("uva") < 0
0
true
auto operator<=>(…) C++20A “nave espacial”: compara de uma vez (devolve std::strong_ordering). Aula(s <=> "uva") < 0true

Texto ↔ número (funções livres, <string>)

Método ou funçãoO que fazExemploResultado
int stoi(const string& s, size_t* pos = nullptr, int base = 10) C++11Texto → int. Pula espaços no começo e para no primeiro caractere que não é dígito. Nada aproveitável: std::invalid_argument; grande demais: std::out_of_range. Aulastd::stoi("42")
std::stoi(" 42 reais")
std::stoi("ff", nullptr, 16)
std::stoi("abc")
std::stoi("99999999999")
42
42
255
lança std::invalid_argument
what(): stoi
lança std::out_of_range
what(): stoi
long stol(…) · long long stoll(…) C++11O mesmo para long e long long. Aulastd::stoll("99999999999")99999999999
unsigned long stoul(…) · stoull(…) C++11Para sem sinal. Cuidado: "-1" não dá erro, dá a volta. Aulastd::stoul("-1")18446744073709551615
double stod(const string& s, size_t* pos = nullptr) C++11Texto → double. Também stof (float) e stold. Usa ponto decimal. Aulastd::stod("3.14")
std::stod("2,5")
std::stod("1e3")
3.14
2
1000
string to_string(número) C++11Número → texto. Com double, sempre 6 casas. Aulastd::to_string(42)
std::to_string(3.14)
std::to_string(0.1 + 0.2)
"42"
"3.140000"
"0.300000"
string format("…{}…", args…) C++20Monta um texto com marcadores {}. Precisa de -std=c++20 ou mais. Veja a tabela de máscaras na aula. Aulastd::format("{} tem {} anos", "Ana", 30)
std::format("{:.2f}", 3.14159)
std::format("[{:>6}]", "oi")
std::format("{:05}", 42)
std::format("{}", 0.1 + 0.2)
"Ana tem 30 anos"
"3.14"
"[ oi]"
"00042"
"0.30000000000000004"

Outras funções livres

Método ou funçãoO que fazExemploResultado
istream& getline(istream& in, string& s, char delim = '\n')Lê até o fim da linha (ou até delim), sem guardá-lo. Devolve o fluxo, que vale false no fim da entrada. Exemplo completo abaixo. Aulastd::istringstream entrada{"Ana;Bia;Caio"}; std::string t;
std::getline(entrada, t, ';'); t

"Ana"
size_t erase(string& s, char c) C++20Apaga todas as ocorrências de c; devolve quantas apagou. std::erase_if(s, condição) apaga por condição. Aulastd::erase(s, 'a')s = "bnn"
ranges::transform(s, s.begin(), f) C++20Aplica f a cada caractere (com <algorithm> e <cctype>). Só muda as letras sem acento. Aulastd::ranges::transform(s, s.begin(), [](unsigned char c) { return std::toupper(c); })s = "BANANA"
ranges::reverse(s) C++20Inverte o texto (byte a byte: estraga acentos). Aulastd::ranges::reverse(s)s = "ananab"
string(size_type n, char c)Construtor: n cópias de c. Aulastd::string(5, '-')"-----"
"…"s C++14Literal de std::string (com using namespace std::literals;). Permite "a"s + "b". Aula"ba"s + "na""bana"

getline × >>

O >> lê uma palavra (para no espaço); o getline lê a linha inteira:

#include <iostream>
#include <string>

int main() {
    std::string nome;
    std::cout << "Nome completo: ";
    std::getline(std::cin, nome);
    std::cout << "Olá, " << nome << "! (" << nome.size() << " bytes)\n";

    std::string primeiro;
    std::cout << "De novo: ";
    std::cin >> primeiro;
    std::cout << "Com >>: " << primeiro << '\n';
}
$ g++ -std=c++23 -Wall -Wextra nome.cpp -o nome
$ ./nome
Nome completo: Ana Maria Souza
Olá, Ana Maria Souza! (15 bytes)
De novo: Bruno Lima
Com >>: Bruno

Cuidado ao misturar os dois na ordem contrária: depois de um std::cin >> idade;, o Enter fica esperando, e o próximo getline lê uma linha vazia. A aula getline mostra o problema e o std::ws que resolve.

Missão: o programa deve mostrar só o nome do arquivo, notas.txt, a partir do caminho. Ache a última barra com um método da tabela Procurar e pegue o resto com substr.

#include <iostream>
#include <string>

int main() {
    std::string caminho = "/home/ana/notas.txt";
    // seu código aqui
}
#include <iostream>
#include <string>

int main() {
    std::string caminho = "/home/ana/notas.txt";
    std::size_t barra = caminho.find_last_of('/');
    std::string arquivo = caminho.substr(barra + 1);
    std::cout << arquivo << '\n';
}

Por versão do C++

VersãoO que chegou para texto
C++98std::string com size, find, substr, replace, insert, erase, compare, getline…
C++11front, back, pop_back, stoi/stod e família, to_string, u8"…", raw strings R"(…)", std::u16string/std::u32string.
C++14Literal "…"s.
C++17std::string_view, std::from_chars/std::to_chars (conversão rápida, sem exceções).
C++20starts_with, ends_with, std::format, std::erase/std::erase_if, <=>, char8_t e std::u8string.
C++23contains, std::print/std::println, resize_and_overwrite.