A maneira mais fácil de converter int em string em C ++

Qual é a maneira mais fácil de converter de int para string equivalente em C ++. Eu estou ciente de dois methods. Existe alguma maneira mais fácil?

(1)

 int a = 10; char *intStr = itoa(a); string str = string(intStr); 

(2)

 int a = 10; stringstream ss; ss << a; string str = ss.str(); 

C ++ 11 introduz std::stoi (e variantes para cada tipo numérico) e std::to_string , as contrapartes do C atoi e itoa mas expressas em termo de std::string .

 #include  std::string s = std::to_string(42); 

é, portanto, o caminho mais curto que posso pensar. Você pode até omitir a nomeação do tipo, usando a palavra-chave auto :

 auto s = std::to_string(42); 

Nota: veja [string.conversions] ( 21,5 em n3242 )

Pegando uma discussão com @ v.oddou alguns anos depois, o C ++ 17 finalmente entregou uma maneira de fazer a solução independente de tipo baseada em macro original (preservada abaixo) sem passar pela macro feiura.

 template < typename... Args > std::string sstr( Args &&... args ) { std::ostringstream sstr; ( sstr < < std::dec << ... << args ); return sstr.str(); } 

Uso:

 int i = 42; std::string s = sstr( "i is: ", i ); puts( sstr( i ).c_str() ); Foo x( 42 ); throw std::runtime_error( sstr( "Foo is '", x, "', i is ", i ) ); 

Resposta original:

Como "converter ... em string" é um problema recorrente, eu sempre defino a macro SSTR () em um header central de minhas fonts C ++:

 #include  #define SSTR( x ) static_cast< std::ostringstream & >( \ ( std::ostringstream() < < std::dec << x ) ).str() 

O uso é tão fácil quanto poderia ser:

 int i = 42; std::string s = SSTR( "i is: " < < i ); puts( SSTR( i ).c_str() ); Foo x( 42 ); throw std::runtime_error( SSTR( "Foo is '" << x << "', i is " << i ) ); 

O acima é compatível com C ++ 98 (se você não pode usar C ++ 11 std::to_string ), e não precisa de quaisquer std::to_string terceiros (se você não pode usar Boost lexical_cast<> ); Ambas as outras soluções têm um desempenho melhor.

Eu costumo usar o seguinte método:

 #include  template  std::string NumberToString ( T Number ) { std::ostringstream ss; ss < < Number; return ss.str(); } 

descrito em detalhes aqui .

Provavelmente, a maneira mais comum envolve a sua segunda escolha em um modelo chamado lexical_cast , como o do Boost , assim seu código se parece com isso:

 int a = 10; string s = lexical_cast(a); 

Uma dica disso é que ele também suporta outros castings (por exemplo, na direção oposta funciona tão bem).

Note também que, embora o Boost lexical_cast tenha começado apenas escrevendo para um stringstream, então extraia de volta o stream, agora ele tem algumas adições. Primeiro de tudo, especializações para alguns tipos foram adicionadas, portanto, para muitos tipos comuns, é substancialmente mais rápido do que usar um stringstream. Segundo, agora ele verifica o resultado, então (por exemplo) se você converter de uma string para um int , ele pode lançar uma exceção se a string contiver algo que não poderia ser convertido em um int (por exemplo, 1234 teria sucesso, mas 123abc jogaria).

A partir do C ++ 11, há uma function std::to_string sobrecarregada para tipos inteiros, então você pode usar código como:

 int a = 20; std::string s = to_string(a); 

O padrão define isso como sendo equivalente a fazer a conversão com sprintf (usando o especificador de conversão que corresponde ao tipo de object fornecido, como %d para int ), em um buffer de tamanho suficiente e, em seguida, criando um std::string do conteúdo desse buffer.

Se você tiver o Boost instalado (o que você deve):

 #include  int num = 4; std::string str = boost::lexical_cast(num); 

Não seria mais fácil usar stringstreams?

 #include  int x=42; //The integer string str; //The string ostringstream temp; //temp as in temporary temp<  

Ou faça uma function:

 #include  string IntToString (int a) { ostringstream temp; temp<  

Não que eu saiba, em puro C ++. Mas uma pequena modificação do que você mencionou

 string s = string(itoa(a)); 

deve funcionar, e é bem curto.

sprintf() é muito bom para conversão de formato. Você pode então atribuir a string C resultante à string C ++ como você fez em 1.

Primeiro inclua:

 #include  #include  

Em segundo lugar, adicione o método:

 template  string NumberToString(T pNumber) { ostringstream oOStrStream; oOStrStream < < pNumber; return oOStrStream.str(); } 

Use o método assim:

 NumberToString(69); 

ou

 int x = 69; string vStr = NumberToString(x) + " Hello word!." 

Você pode usar std::to_string disponível em C ++ 11 como sugerido por Matthieu M .:

 std::to_string(42); 

Ou, se a performance for crítica (por exemplo, se você fizer muitas conversões), você pode usar fmt::FormatInt da biblioteca C ++ Format para converter um inteiro para std::string :

 fmt::FormatInt(42).str(); 

Ou uma string C:

 fmt::FormatInt f(42); f.c_str(); 

O último não faz nenhuma alocação de memory dinâmica e é mais de 10 vezes mais rápido que std::to_string nos benchmarks do Boost Karma. Veja Integer rápido à conversão de string em C ++ para mais detalhes.

Ao contrário de std::to_string , o fmt::FormatInt não requer o C ++ 11 e funciona com qualquer compilador C ++.

Disclaimer: Eu sou o autor da biblioteca C ++ Format.

Usar stringstream para conversão de números é perigoso!

Veja http://www.cplusplus.com/reference/ostream/ostream/operator%3C%3C/ onde diz que o operator< < insere a saída formatada.

Dependendo da sua localidade atual, um número inteiro maior que 3 dígitos pode converter em uma cadeia de 4 dígitos, adicionando um separador extra de milhar.

Por exemplo, int = 1000 poderia ser convertet para uma string 1.001 . Isso pode fazer com que as operações de comparação não funcionem de todo.

Então, eu recomendo fortemente usar a maneira std::to_string . É mais fácil e faz o que você espera.

Para C ++ 98 , há algumas opções:

boost/lexical_cast

O Boost não faz parte da biblioteca C ++, mas contém muitas extensões de biblioteca úteis.

O modelo de function lexical_cast oferece uma forma conveniente e consistente para suportar conversões comuns de e para tipos arbitrários quando elas são representadas como texto.
– Documentação do Boost

 #include "boost/lexical_cast.hpp" #include  int main() { int x = 5; std::string x_str = boost::lexical_cast(x); return 0; } 

Quanto ao tempo de execução, a operação lexical_cast leva cerca de 80 microssegundos (na minha máquina) na primeira conversão e depois acelera consideravelmente depois, se feita de forma redundante.


itoa

Essa function não é definida em ANSI-C e não faz parte do C ++, mas é suportada por alguns compiladores.
– cplusplus.com

Isso significa que o gcc / g++ não pode compilar o código usando itoa .

 #include  int main() { int x = 5; char * x_str = new char[2]; x_str = itoa(x, x_str, 10); // base 10 return 0; } 

Nenhum tempo de execução para relatar. Eu não tenho o Visual Studio instalado, que é declaradamente capaz de compilar itoa .


sprintf

sprintf é uma function de biblioteca padrão C que funciona em strings C e é uma alternativa perfeitamente válida.

Compõe uma string com o mesmo texto que seria impresso se o formato fosse usado em printf, mas em vez de ser impresso, o conteúdo é armazenado como uma string C no buffer apontado por str.
– cplusplus.com

 #include  int main() { int x = 5; char * x_str = new char[2]; int chars_written = sprintf(x_str, "%d", x); return 0; } 

O header stdio.h pode não ser necessário. Quanto ao tempo de execução, a operação sprintf leva cerca de 40 microssegundos (na minha máquina) na primeira conversão e, em seguida, acelera consideravelmente depois, se feita de forma redundante.


stringstream

Essa é a principal maneira de converter inteiros em cadeias de caracteres da biblioteca C ++ e vice-versa. Existem funções irmãs similares ao stringstream que limitam ainda mais o uso pretendido do stream, como o ostringstream . Usar o ostringstream diz especificamente ao leitor do seu código que você pretende usar apenas o operador < < , essencialmente. Esta function é tudo o que é particularmente necessário para converter um inteiro em uma string. Veja esta questão para uma discussão mais elaborada.

 #include  #include  int main() { int x = 5; std::ostringstream stream; stream < < x; std::string x_str = stream.str(); return 0; } 

Quanto ao tempo de execução, a operação ostringstream leva cerca de 71 microssegundos (na minha máquina) e, em seguida, acelera consideravelmente depois, se feita de forma redundante, mas não tanto quanto as funções anteriores .


É claro que existem outras opções, e você pode até envolver uma delas em sua própria function, mas isso oferece uma visão analítica de algumas das mais populares.

Usar:

 #define convertToString(x) #x int main() { convertToString(42); // Returns const char* equivalent of 42 } 

É bastante fácil adicionar um pouco de açúcar sintático que permite compor seqüências de caracteres em tempo real

 #include  #include  struct strmake { std::stringstream s; template  strmake& operator < < (const T& x) { s << x; return *this; } operator std::string() {return s.str();} }; 

Agora você pode append o que quiser (desde que um operador < < (std::ostream& ..) esteja definido para ele) para strmake() e use-o no lugar de um std::string .

Exemplo:

 #include  int main() { std::string x = strmake() < < "Current time is " << 5+5 << ":" << 5*5 << " GST"; std::cout << x << std::endl; } 
 namespace std { inline string to_string(int _Val) { // convert long long to string char _Buf[2 * _MAX_INT_DIG]; snprintf(_Buf, "%d", _Val); return (string(_Buf)); } } 

agora você pode usar to_string(5)

Eu uso:

 int myint = 0; long double myLD = 0.0; string myint_str = static_cast( &(ostringstream() < < myint) )->str(); string myLD_str = static_cast( &(ostringstream() < < myLD) )->str(); 

Ele funciona em meus compiladores windows e linux g ++.

Usando o CString :

 int a = 10; CString strA; strA.Format("%d", a); 
 string number_to_string(int x){ if(!x) return "0"; string s,s2; while(x){ s.push_back(x%10 + '0'); x/=10; } reverse(s.begin(),s.end()); return s; } 
 #include "stdafx.h" #include #include #include std::string intToString(int num); int main() { int integer = 4782151; std::string integerAsStr = intToString(integer); std::cout < < "integer = " << integer << std::endl; std::cout << "integerAsStr = " << integerAsStr << std::endl; return 0; } std::string intToString(int num) { std::string numAsStr; while (num) { char toInsert = (num % 10) + 48; numAsStr.insert(0, 1, toInsert); num /= 10; } return numAsStr; } 
 char * bufSecs = new char[32]; char * bufMs = new char[32]; sprintf(bufSecs,"%d",timeStart.elapsed()/1000); sprintf(bufMs,"%d",timeStart.elapsed()%1000); 

Se você precisar de conversão rápida de um inteiro com um número fixo de dígitos para char * preenchido com ‘0’, este é um exemplo conveniente:

 int n = 27; char s[8]; 

Se você estiver convertendo um número de dois dígitos:

 *(int32_t*)s = 0x3030 | (n/10) | (n%10) < < 8; 

Se você estiver convertendo um número de três dígitos:

 *(int32_t*)s = 0x303030 | (n/100) | (n/10%10) < < 8 | (n%10) << 16; 

Se você estiver convertendo um número de quatro dígitos:

 *(int64_t*)s = 0x30303030 | (n/1000) | (n/100%10)< <8 | (n/10%10)<<16 | (n%10)<<24; 

E assim por diante até sete dígitos números 🙂

Aqui está outra maneira fácil de fazer

 char str[100] ; sprintf(str , "%d" , 101 ) ; string s = str; 

O sprintf é bem conhecido para inserir qualquer dado em uma string de formato requerido.

Você pode converter o array char * em string, como mostrado na terceira linha.

 int n = 123; std::string str = std::to_string(n); 

Você usa um tipo de algoritmo de contador para converter em uma string. Eu tenho essa técnica de programar computadores Commodore 64 . Também é bom para programação de jogos.

  • Você pega o inteiro e pega cada dígito que é ponderado por potências de 10. Então, suponha que o inteiro seja 950.

    • Se o número inteiro for igual ou maior que 100.000, subtraia 100.000 e aumente o contador na string em [“000000”];
      Continue fazendo isso até não mais números na posição 100.000. Solte outro poder de dez

    • Se o inteiro for igual ou maior que 10.000, subtraia 10.000 e aumente o contador na string em [“000000”] + 1 posição;
      Continue fazendo isso até não mais números na posição 10.000.

  • Solte outro poder de dez

  • Repetir o padrão

Eu sei que 950 é muito pequeno para usar como exemplo, mas espero que você entenda.