Qual é a maneira mais fácil de converter de int
para equivalente string
em C++. Eu estou ciente de dois métodos. 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();
Pegando uma discussão com @v.oddou um par de anos depois, C++17 finalmente entregou uma maneira de fazer a solução originalmente baseada em macro (preservada abaixo) sem passar por macro fealdade.
// variadic template
template < typename... Args >
std::string sstr( Args &&... args )
{
std::ostringstream sstr;
// fold expression
( 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 cabeçalho central das minhas fontes C++:
#include <sstream>
#define SSTR( x ) static_cast< std::ostringstream & >( \
( std::ostringstream() << std::dec << x ) ).str()
A utilização é tão fácil quanto possível:
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 puder utilizar C++11 std::to_string
), e não precisa de nenhum terceiro inclui (se você não puder utilizar Boost lexical_cast<>
); ambas as outras soluções têm um melhor desempenho, no entanto.
Provavelmente a maneira mais comum e fácil envolve essencialmente sua segunda escolha em um template chamado lexical_cast
, como o do Boost, então seu código se parece com este:
int a = 10;
string s = lexical_cast<string>(a);
Uma das vantagens disto é que também suporta outros elencos (por exemplo, na direcção oposta funciona igualmente bem).
Note também que embora o Boost lexical_cast tenha começado como uma simples escrita para um stringstream, e depois extraído de volta para fora do fluxo, agora tem algumas adições. Primeiro de tudo, especializações para alguns tipos foram adicionadas, então para muitos tipos comuns, é substancialmente mais rápido do que usar um stringstream. Segundo, ele agora 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 contém algo que não poderia ser convertido para um int
(por exemplo, 1234
seria bem sucedido, mas 123abc
seria lançado).
A partir de C++11, há uma função std::to_string
sobrecarregada para tipos inteiros, para que você possa utilizar código como:
int a = 20;
std::string s = to_string(a);
O padrão os define como sendo equivalentes a fazer a conversão com sprintf' (utilizando o especificador de conversão que corresponde ao tipo de objeto fornecido, como
%d' para int'), em um buffer de tamanho suficiente, criando então um
std::string' do conteúdo desse buffer.