Pregunta La forma más fácil de convertir int a cadena en C ++


¿Cuál es la forma más fácil de convertir de int a equivalente string en C ++. Conozco dos métodos. ¿Hay alguna manera más 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();

1208
2018-04-08 04:19


origen


Respuestas:


C ++ 11 presenta std::stoi (y variantes para cada tipo numérico) y std::to_string, las contrapartidas de la C atoi y itoa pero expresado en términos de std::string.

#include <string> 

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

es, por lo tanto, la forma más breve en que puedo pensar. Incluso puede omitir el nombre del tipo, utilizando auto palabra clave:

auto s = std::to_string(42);

Nota: ver [string.conversions] (21.5 en n3242)


1592
2018-04-08 06:13



Tras retomar una discusión con @ v.oddou un par de años después, C ++ 17 finalmente ha proporcionado una forma de hacer la solución agnóstica de tipo originalmente basada en macro (preservada a continuación) sin pasando por la fealdad macro.

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 ) );

Respuesta original:

Dado que "convertir ... a una cadena" es un problema recurrente, siempre defino la SSTR () macro en un encabezado central de mis fuentes de C ++:

#include <sstream>

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

El uso es tan fácil como podría 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 ) );

Lo anterior es compatible con C ++ 98 (si no puede usar C ++ 11 std::to_string), y no necesita ningún proveedor de terceros (si no puede usar Boost) lexical_cast<>); estas otras soluciones tienen un mejor rendimiento sin embargo.


165
2018-04-08 04:23



Usualmente uso el siguiente método:

#include <sstream>

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

descrito en detalles aquí.


96
2017-11-29 22:46



Probablemente la forma fácil más común envuelve esencialmente su segunda opción en una plantilla llamada lexical_cast, como el de Aumentar, entonces tu código se ve así:

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

Una buena parte de esto es que también admite otros moldes (por ejemplo, en la dirección opuesta funciona igual de bien).

También tenga en cuenta que, aunque Boost lexical_cast comenzó como una simple escritura en un flujo de cadena, y luego se extrae de la secuencia, ahora tiene un par de adiciones. En primer lugar, se han agregado especializaciones para bastantes tipos, por lo que para muchos tipos comunes, es sustancialmente más rápido que usar un stringstream. En segundo lugar, ahora verifica el resultado, por lo que (por ejemplo) si convierte de una cadena a una int, puede arrojar una excepción si la cadena contiene algo que no podría convertirse en int (p.ej., 1234 tendría éxito, pero 123abc tiraría).

A partir de C ++ 11, hay un std::to_string función sobrecargada para tipos enteros, para que pueda usar código como:

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

El estándar los define como equivalentes a hacer la conversión con sprintf (usando el especificador de conversión que coincide con el tipo de objeto suministrado, como %d para int), en un buffer de tamaño suficiente, luego creando un std::string de los contenidos de ese buffer.


84
2018-04-08 04:23



Si tiene instalado Boost (que debería):

#include <boost/lexical_cast.hpp>

int num = 4;
std::string str = boost::lexical_cast<std::string>(num);

40
2018-04-08 04:26



¿No sería más fácil usar cadenas de caracteres?

#include <sstream>

int x=42;            //The integer
string str;          //The string
ostringstream temp;  //temp as in temporary
temp<<x;
str=temp.str();      //str is temp as string

O haz una función:

#include <sstream>

string IntToString (int a)
{
    ostringstream temp;
    temp<<a;
    return temp.str();
}

27
2018-04-16 19:37



No es que yo sepa, en C ++ puro. Pero una pequeña modificación de lo que mencionaste

string s = string(itoa(a));

debería funcionar, y es bastante corto.


19
2018-04-08 04:22



sprintf() es bastante bueno para la conversión de formato. A continuación, puede asignar la cadena C resultante a la cadena C ++ como lo hizo en 1.


16
2018-04-08 04:23



Primero incluye:

#include <string>
#include <sstream>

Segundo agrega el método:

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

Usa el método así:

NumberToString(69);

o

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

12
2018-05-31 21:32



Puedes usar std::to_string disponible en C ++ 11 como sugerido por Matthieu M.:

std::to_string(42);

O bien, si el rendimiento es crítico (por ejemplo, si realiza muchas conversiones), puede usar fmt::FormatInt desde el Formato C ++ biblioteca para convertir un entero a std::string:

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

O una cadena C:

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

Este último no realiza ninguna asignación de memoria dinámica y es más de 10 veces más rápido que std::to_string en los puntos de referencia de Boost Karma. Ver Número entero rápido para la conversión de cadenas en C ++ para más detalles.

diferente a std::to_string, fmt::FormatInt no requiere C ++ 11 y funciona con cualquier compilador C ++.

Descargo de responsabilidad: soy el autor de la biblioteca de formato C ++.


9
2018-05-25 13:42