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.
- Em todos os exemplos,
scomeça comostd::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
sficou:s="bananas". - Índices começam em 0: em
"banana", obestá na posição 0 e o últimoana 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_viewou umcharno lugar deconst 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ção | O que faz | Exemplo | Resultado |
|---|---|---|---|
size_type size() const | Quantos bytes (char) o texto tem. Um é em UTF-8 conta 2. Aula | s.size()std::string t = "café";t.size() | 65 |
size_type length() const | O mesmo que size(). Aula | s.length() | 6 |
bool empty() const | true se o tamanho é 0. Mais claro que size() == 0. Aula | s.empty()std::string{}.empty() | falsetrue |
void clear() | Apaga tudo: o texto fica vazio. Aula | s.clear() | s = "" |
void resize(size_type n, char c = '\0') | Muda o tamanho: corta o fim ou completa com c. Aula | s.resize(3)s.resize(8, '!') | s = "ban"s = "banana!!" |
size_type capacity() const | Quantos bytes cabem sem pedir mais memória. Textos curtos cabem dentro do próprio objeto (15 bytes no g++). Aula | s.capacity() | 15 |
void reserve(size_type n) | Reserva espaço para n bytes de uma vez, antes de muitos +=. Aula | s.reserve(100); s.capacity() | 100 |
Acessar caracteres
| Método ou função | O que faz | Exemplo | Resultado |
|---|---|---|---|
char& operator[](size_type i) | O caractere na posição i (começa em 0). Fora do tamanho: comportamento indefinido, sem aviso. Aula | s[0]s[5] | 'b''a' |
char& at(size_type i) | Igual, mas confere: fora do tamanho, lança std::out_of_range. Aula | s.at(1)s.at(10) | 'a'lança std::out_of_rangewhat(): basic_string::at: __n (which is 10) >= this->size() (which is 6) |
char& front() C++11 | O primeiro caractere (texto não pode estar vazio). Aula | s.front() | 'b' |
char& back() C++11 | O último caractere. Aula | s.back() | 'a' |
const char* c_str() const | Um ponteiro para o texto terminado em '\0', para funções do C. data() é quase igual. Aula | std::strlen(s.c_str()) | 6 |
Juntar e modificar
| Método ou função | O que faz | Exemplo | Resultado |
|---|---|---|---|
string& operator+=(…) | Acrescenta no fim um texto, um char ou outra string. Aula | s += "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. Aula | s + " madura" | "banana madura" |
string& append(const string& t) | Acrescenta t no fim (como +=). Aula | s.append("da") | s = "bananada" |
string& append(size_type n, char c) | Acrescenta n cópias de c. Aula | s.append(3, '!') | s = "banana!!!" |
void push_back(char c) | Acrescenta um caractere. Aula | s.push_back('s') | s = "bananas" |
void pop_back() C++11 | Tira o último caractere. Aula | s.pop_back() | s = "banan" |
string& insert(size_type pos, const string& t) | Insere t antes da posição pos. Aula | s.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. Aula | s.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). Aula | s.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"). Aula | s.assign(3, 'z') | s = "zzz" |
void swap(string& t) | Troca o conteúdo de duas strings (rápido: não copia o texto). Aula | std::string s = "banana"; std::string t = "uva";s.swap(t) | s = "uva" |
Pedaços
| Método ou função | O que faz | Exemplo | Resultado |
|---|---|---|---|
string substr(size_type pos = 0, size_type n = npos) const | Uma 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. Aula | s.substr(2)s.substr(1, 3)s.substr(4, 100)s.substr(7) | "nana""ana""na"lança std::out_of_rangewhat(): 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ção | O que faz | Exemplo | Resultado |
|---|---|---|---|
size_type find(const string& t, size_type pos = 0) const | Posição da primeira ocorrência de t a partir de pos, ou npos se não achar. Aula | s.find("na")s.find("na", 3)s.find("x") | 24npos |
size_type find(char c, size_type pos = 0) const | O mesmo para um caractere. Aula | s.find('a') | 1 |
size_type rfind(const string& t) const | A última ocorrência. Aula | s.rfind("na")s.rfind('a') | 45 |
size_type find_first_of(const string& cs) const | Primeira posição de qualquer um dos caracteres de cs. Aula | s.find_first_of("nb")std::string t = "Ana;Bia,Caio";t.find_first_of(",;") | 03 |
size_type find_last_of(const string& cs) const | Última posição de qualquer um dos caracteres. Aula | std::string t = "/home/ana/notas.txt";t.find_last_of("/") | 9 |
size_type find_first_not_of(const string& cs) const | Primeira posição de um caractere que não está em cs. Bom para pular espaços. Aula | std::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. Aula | std::string t = " oi ";t.find_last_not_of(" ") | 4 |
bool contains(const string& t) const C++23 | true se t aparece em algum lugar. Aula | s.contains("nan")s.contains('x') | truefalse |
bool starts_with(const string& t) const C++20 | Começa com t? Aula | s.starts_with("ba") | true |
bool ends_with(const string& t) const C++20 | Termina com t? Aula | s.ends_with("na")std::string t = "notas.TXT";t.ends_with(".txt") | truefalse |
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ção | O que faz | Exemplo | Resultado |
|---|---|---|---|
== != < <= > >= | Comparam o conteúdo, byte a byte (ordem de dicionário pelos códigos: maiúsculas antes das minúsculas, acentuadas depois de tudo). Aula | s == "banana"s < "bala"std::string("Zebra") < "abacate" | truefalsetrue |
int compare(const string& t) const | Negativo se s vem antes, 0 se igual, positivo se vem depois. Aula | s.compare("banana")s.compare("uva") < 0 | 0true |
auto operator<=>(…) C++20 | A “nave espacial”: compara de uma vez (devolve std::strong_ordering). Aula | (s <=> "uva") < 0 | true |
Texto ↔ número (funções livres, <string>)
| Método ou função | O que faz | Exemplo | Resultado |
|---|---|---|---|
int stoi(const string& s, size_t* pos = nullptr, int base = 10) C++11 | Texto → 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. Aula | std::stoi("42")std::stoi(" 42 reais")std::stoi("ff", nullptr, 16)std::stoi("abc")std::stoi("99999999999") | 4242255lança std::invalid_argumentwhat(): stoilança std::out_of_rangewhat(): stoi |
long stol(…) · long long stoll(…) C++11 | O mesmo para long e long long. Aula | std::stoll("99999999999") | 99999999999 |
unsigned long stoul(…) · stoull(…) C++11 | Para sem sinal. Cuidado: "-1" não dá erro, dá a volta. Aula | std::stoul("-1") | 18446744073709551615 |
double stod(const string& s, size_t* pos = nullptr) C++11 | Texto → double. Também stof (float) e stold. Usa ponto decimal. Aula | std::stod("3.14")std::stod("2,5")std::stod("1e3") | 3.1421000 |
string to_string(número) C++11 | Número → texto. Com double, sempre 6 casas. Aula | std::to_string(42)std::to_string(3.14)std::to_string(0.1 + 0.2) | "42""3.140000""0.300000" |
string format("…{}…", args…) C++20 | Monta um texto com marcadores {}. Precisa de -std=c++20 ou mais. Veja a tabela de máscaras na aula. Aula | std::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ção | O que faz | Exemplo | Resultado |
|---|---|---|---|
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. Aula | std::istringstream entrada{"Ana;Bia;Caio"}; std::string t;std::getline(entrada, t, ';'); t | "Ana" |
size_t erase(string& s, char c) C++20 | Apaga todas as ocorrências de c; devolve quantas apagou. std::erase_if(s, condição) apaga por condição. Aula | std::erase(s, 'a') | s = "bnn" |
ranges::transform(s, s.begin(), f) C++20 | Aplica f a cada caractere (com <algorithm> e <cctype>). Só muda as letras sem acento. Aula | std::ranges::transform(s, s.begin(), [](unsigned char c) { return std::toupper(c); }) | s = "BANANA" |
ranges::reverse(s) C++20 | Inverte o texto (byte a byte: estraga acentos). Aula | std::ranges::reverse(s) | s = "ananab" |
string(size_type n, char c) | Construtor: n cópias de c. Aula | std::string(5, '-') | "-----" |
"…"s C++14 | Literal 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ão | O que chegou para texto |
|---|---|
| C++98 | std::string com size, find, substr, replace, insert, erase, compare, getline… |
| C++11 | front, back, pop_back, stoi/stod e família, to_string, u8"…", raw strings R"(…)", std::u16string/std::u32string. |
| C++14 | Literal "…"s. |
| C++17 | std::string_view, std::from_chars/std::to_chars (conversão rápida, sem exceções). |
| C++20 | starts_with, ends_with, std::format, std::erase/std::erase_if, <=>, char8_t e std::u8string. |
| C++23 | contains, std::print/std::println, resize_and_overwrite. |