1. std::stoi: ideia básica
Às vezes parece que ler um número é sempre std::cin >> x; e pronto. Mas assim que você quiser ler a linha inteira (por exemplo, “Nome Sobrenome”, endereço, comentário, uma frase com espaços), você quase automaticamente passa a usar std::getline. E aí surge a tarefa prática: “Ok, li a string, mas ali tem um número, como faço para transformá-la em int?”.
Imagine um formulário de console: nome — string, ano de nascimento — aparentemente um número, mas você quer ler tudo via getline, para que a entrada seja uniforme e sem surpresas. Ou o usuário digita uma quantia 1500, mas você prefere ler primeiro como texto (string) e depois interpretar como número. É aqui que aparece std::stoi.
std::stoi é uma função da biblioteca padrão do C++ que tenta interpretar uma string como um inteiro do tipo int. Se tudo der certo, você obtém um int e pode fazer aritmética, comparações etc.
Mas a conclusão prática é uma só: stoi — a ponte entre o mundo do texto e o mundo dos números.
Sintaxe mínima: string → int
Na forma mínima stoi funciona assim: pegamos uma std::string e obtemos um int. O principal é incluir <string>, porque tanto std::string quanto std::stoi estão lá.
#include <iostream>
#include <string>
int main() {
std::string text = "42";
int value = std::stoi(text);
std::cout << value << '\n'; // 42
}
Neste exemplo a string "42" é perfeita para virar número. Por isso std::stoi funciona “sem drama”: você recebe 42.
Integrando stoi na entrada “ao vivo” via getline
O próximo passo é fazer aquilo para o qual geralmente se usa stoi: ler uma linha (normalmente via getline) e transformá‑la em número.
Aqui é importante não ter pressa. Lemos a linha como texto, e só depois dizemos: “Agora vamos tentar convertê‑la em número”.
#include <iostream>
#include <string>
int main() {
std::string line;
std::getline(std::cin, line);
int n = std::stoi(line);
std::cout << "n = " << n << '\n'; // por exemplo: n = 15
}
Repare no aspecto psicológico: o programa “educadamente” primeiro captura a entrada em formato seguro (string) e depois faz o passo de interpretação. Isso costuma ser mais conveniente do que tentar ler um int diretamente, especialmente se o formato de entrada for mais complexo do que “um número sem espaços”.
3. Exemplo prático: mini‑formulário
Vamos continuar com um aplicativo didático — um formulário de console. Antes disso você já poderia imprimir perguntas com std::cout, ler o nome com getline, e agora vamos adicionar a leitura de um número como string e a conversão via stoi.
A ideia é simples: pedimos o nome (string), pedimos o ano de nascimento (string), convertemos o ano para int e calculamos a idade em relação a um ano fixo (digamos 2026 — só como exemplo; sim, o calendário do programa está “na tomada”).
#include <iostream>
#include <string>
int main() {
std::string fullName;
std::string birthYearText;
std::cout << "Digite nome e sobrenome: ";
std::getline(std::cin, fullName);
std::cout << "Digite o ano de nascimento (por exemplo, 2005): ";
std::getline(std::cin, birthYearText);
int birthYear = std::stoi(birthYearText);
int age = 2026 - birthYear;
std::cout << "Olá, " << fullName << "!\n";
std::cout << "Você tem aproximadamente " << age << " anos.\n";
}
Note como evitamos misturar >> e getline: lemos tudo via getline, o que torna o comportamento de entrada previsível. Enquanto você é iniciante, “previsibilidade” costuma ser mais importante do que “posso digitar o número com um comando cin >>”.
4. Comportamento do stoi: o que ele “perdoa” e o que faz de forma traiçoeira
Espaços iniciais e sinal do número
Às vezes os usuários não digitam perfeitamente. Por exemplo, colocam espaços no início. A boa notícia: std::stoi ignora espaços iniciais. A má notícia: isso pode criar a impressão de que ele “perdoa tudo”, e isso é uma ilusão perigosa.
#include <iostream>
#include <string>
int main() {
std::string text = " 15";
int value = std::stoi(text);
std::cout << value << '\n'; // 15
}
Os espaços no início não atrapalharam. Isso é conveniente, mas também indica: stoi não é um “parser rígido”, e sim um algoritmo que tenta inferir o que você quis dizer.
Conversão parcial: número no início, lixo depois
Aqui começa o mais interessante (e o mais traiçoeiro). A string pode conter um número no início e depois lixo. E std::stoi frequentemente pega o número do início e para no primeiro caractere incompatível.
Ou seja, a string "12kg" pode se transformar no número 12.
#include <iostream>
#include <string>
int main() {
std::string text = "12kg";
int value = std::stoi(text);
std::cout << value << '\n'; // 12
}
Por que isso importa? Porque por sentido "12kg" não é um número puro, é “número + unidade”. Às vezes esse comportamento é útil (por exemplo, quando você sabe que o formato é exatamente esse: número no início e sufixo depois). Mas frequentemente o iniciante espera rigor: “Se não for número puro — é erro”. E stoi pode “concordar silenciosamente” e entregar meia‑verdade.
Para ilustrar:
| String de entrada | O que você poderia esperar | O que stoi frequentemente faz |
|---|---|---|
|
|
|
|
erro ou 42 | |
|
erro | |
|
erro | erro de execução (frequentemente) |
|
erro | erro de execução (frequentemente) |
A palavra “frequentemente” aqui não é para escapar da responsabilidade, mas um lembrete: o comportamento exato nos detalhes requer leitura da especificação e tratamento consciente de erros. Por enquanto estamos no nível “entender a ideia e ver as limitações”.
5. Limitações do stoi: por que pode ocorrer erro de execução
Ponto importante: std::stoi não é mágica, é uma função que pode “não dar conta”.
Se a string não se parece com um número (por exemplo, "hello", string vazia "", ou algo com magnitude maior que a capacidade de int), ao chamar stoi o programa pode terminar com erro de execução. Na prática isso se manifesta assim: você roda o programa, digita algo “inadequado” e ele encerra repentinamente (às vezes com uma mensagem, às vezes só “Runtime error”).
E aqui é importante não cair em extremos.
O primeiro extremo — pânico: “Pronto, não se deve usar stoi”. Dá para usar, só é preciso entender o escopo: nesta palestra usamos stoi como demonstração de conversão quando a entrada é correta.
O segundo extremo — excesso de confiança: “Se às vezes funciona até com "12kg", então é inteligente e vai se virar sozinho”. Não. Ele não “entende o sentido”, apenas aplica seu algoritmo; se a entrada foge do esperado — terá erro de execução.
Iniciantes frequentemente encontraram erro de execução numa situação assim: depois de std::getline obtiveram uma string vazia (por exemplo, por causa do restante '\n' depois de um >>), e então chamaram stoi nessa string vazia. String vazia não é número e stoi normalmente “cai”.
6. Ligação entre getline e o operador >>
Agora um pequeno elo com o tema do “resto '\n'”, sem repetir tudo. Vamos mostrar por que isso é importante especificamente para stoi.
Se você primeiro lê um número via std::cin >> e depois quer ler uma linha com getline, muitas vezes o primeiro getline recebe uma string vazia. E se depois você passar essa string vazia para stoi, será bem triste.
Portanto, se seu formato de entrada é misto, use um “getline de transição” para consumir o resto da linha.
#include <iostream>
#include <string>
int main() {
int a = 0;
std::string dummy;
std::string numberLine;
std::cin >> a;
std::getline(std::cin, dummy); // consumiu o resto '\n'
std::getline(std::cin, numberLine); // lemos a linha
int b = std::stoi(numberLine);
std::cout << (a + b) << '\n';
}
No nosso nível isso funciona como regra de higiene: se você decidiu converter string para número via stoi, primeiro verifique que leu uma string não vazia e não acidental.
7. Conversão e validação: não confundir
É muito útil separar de antemão dois conceitos.
Conversão — “eu já tenho uma string correta com número, transforme‑a em int”. É isso que stoi faz no uso que mostramos hoje.
Validação — “verifique que a string é realmente um número válido e trate erros com cuidado”. Isso é uma tarefa de engenharia à parte, que exige entrada mais robusta, tratamento de exceções ou outras ferramentas da biblioteca padrão. Não vamos abordar isso agora: não por ser “proibido”, mas porque existe uma ordem nas matérias e não queremos transformar aulas iniciais em um “maratona de sofrimento”.
Logo, o escopo honesto desta palestra é: std::stoi aqui é demonstração da mecânica “string → int” e apresentação das limitações.
8. Erros típicos ao trabalhar com std::stoi
Erro nº1: tratar stoi como “verificador de validade”.
O iniciante costuma pensar: “Se stoi retornou um número — então a string é válida”. Mas a string "12kg" pode resultar em 12 e o programa segue como se estivesse tudo certo. Isso não é validação, é extrair um número do início da string.
Erro nº2: passar string vazia para stoi após getline.
String vazia é um resultado normal de getline (o usuário pode ter pressionado Enter, ou você pode ter lido por engano o resto '\n'). Mas para stoi string vazia normalmente significa erro de execução. Portanto “li a string” e “li uma string com número” não são a mesma coisa.
Erro nº3: esquecer que stoi trabalha com int, e que int não é infinito.
Mesmo que a string pareça um número, ela pode ser grande demais para o intervalo de int. Nesse caso stoi pode causar erro de execução. Basta lembrar: tipos têm intervalos, e a entrada pode ser “muito grande”.
Erro nº4: misturar std::cin >> e std::getline sem “linha de transição”, e depois culpar stoi.
É fácil confundir causa e efeito: o programa cai em stoi, mas a causa real é que getline leu uma string vazia por causa do restante '\n'. Parece que “stoi quebrou”, quando na verdade a lógica de entrada quebrou.
Erro nº5: esquecer de incluir <string>.
Às vezes o código compila em um ambiente e não compila em outro, e o aluno começa a suspeitar de conspiração do compilador. Na prática std::string e std::stoi vivem no cabeçalho <string>, e é melhor incluí‑lo explicitamente para garantir portabilidade e clareza.
GO TO FULL VERSION