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 una string equivalente 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(); 

C ++ 11 introduce std::stoi (y variantes para cada tipo numérico) y std::to_string , las contrapartes de C atoi e itoa pero expresadas en términos de std::string .

 #include  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 la palabra clave auto :

 auto s = std::to_string(42); 

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

Tras retomar una discusión con @ v.oddou un par de años más tarde, 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 pasar 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:

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

 #include  #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 ninguna parte de terceros (si no puede usar Boost lexical_cast<> ); estas otras soluciones tienen un mejor rendimiento sin embargo.

Usualmente uso el siguiente método:

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

descrito en detalle aquí .

Probablemente la forma fácil más común envuelva esencialmente su segunda opción en una plantilla llamada lexical_cast , como la de Boost , para que su código se vea así:

 int a = 10; string s = lexical_cast(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 comprueba el resultado, por lo que (por ejemplo) si convierte de una cadena a un int , puede lanzar una excepción si la cadena contiene algo que no podría convertirse en un int (por ejemplo, 1234 tendría éxito, pero 123abc arrojaría).

A partir de C ++ 11, hay una función std::to_string sobrecargada para tipos enteros, por lo que puede 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 búfer de tamaño suficiente, y luego creando una std::string del contenido de ese buffer.

Si tiene instalado Boost (que debería):

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

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

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

O haz una función:

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

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.

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.

Primero incluye:

 #include  #include  

Segundo agrega el método:

 template  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!." 

Puede usar std::to_string disponible en C ++ 11 como lo sugirió Matthieu M.

 std::to_string(42); 

O bien, si el rendimiento es crítico (por ejemplo, si realiza muchas conversiones), puede usar fmt::FormatInt de la biblioteca de formato C ++ para convertir un entero en 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. Consulte Entero rápido para la conversión de cadenas en C ++ para obtener más detalles.

A diferencia de std::to_string , fmt::FormatInt no requiere C ++ 11 y funciona con cualquier comstackdor de C ++.

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

¡Usar stringstream para la conversión de números es peligroso!

Consulte http://www.cplusplus.com/reference/ostream/ostream/operator%3C%3C/ donde indica que el operator<< inserta la salida formateada.

Dependiendo de su configuración regional actual, un entero de más de 3 dígitos, podría convertirse en una cadena de 4 dígitos, agregando un separador extra de miles.

Por ejemplo, int = 1000 podría convertirse en una cadena 1.001 . Esto podría hacer que las operaciones de comparación no funcionen en absoluto.

Por lo tanto, recomiendo encarecidamente utilizar el modo std::to_string . Es más fácil y hace lo que esperas.

Para C ++ 98 , hay algunas opciones:

boost/lexical_cast

Boost no forma parte de la biblioteca C ++, pero contiene muchas extensiones de biblioteca útiles.

La plantilla de función lexical_cast ofrece una forma conveniente y consistente para admitir conversiones comunes hacia y desde tipos arbitrarios cuando se representan como texto.
– Documentación de Boost

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

En cuanto al tiempo de ejecución, la operación lexical_cast toma aproximadamente 80 microsegundos (en mi máquina) en la primera conversión, y luego se acelera considerablemente después si se realiza de forma redundante.


itoa

Esta función no está definida en ANSI-C y no es parte de C ++, pero es compatible con algunos comstackdores.
– cplusplus.com

Esto significa que gcc / g++ no puede comstackr 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; } 

No hay tiempo de ejecución para informar. No tengo instalado Visual Studio, que supuestamente puede comstackr itoa .


sprintf

sprintf es una función de biblioteca estándar C que funciona en cadenas C, y es una alternativa perfectamente válida.

Compone una cadena con el mismo texto que se imprimirá si se usó el formato en printf, pero en lugar de imprimirse, el contenido se almacena como una cadena C en el búfer señalado 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; } 

El encabezado stdio.h puede no ser necesario. En cuanto al tiempo de ejecución, la operación de sprintf toma aproximadamente 40 microsegundos (en mi máquina) en la primera conversión, y luego se acelera considerablemente después si se realiza de forma redundante.


stringstream

Esta es la principal forma de la biblioteca de C ++ de convertir enteros en cadenas, y viceversa. Hay funciones hermanas similares a stringstream que limitan aún más el uso previsto de la secuencia, como ostringstream . El uso de ostringstream le dice específicamente al lector de tu código que solo pretendes usar el operador << , esencialmente. Esta función es todo lo que es particularmente necesario para convertir un entero en una cadena. Vea esta pregunta para una discusión más elaborada.

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

En cuanto al tiempo de ejecución, la operación ostringstream tarda aproximadamente 71 microsegundos (en mi máquina), y luego se acelera considerablemente después si se realiza de forma redundante, pero no tanto como las funciones anteriores .


Por supuesto, hay otras opciones, e incluso puede incluir una de ellas en su propia función, pero ofrece una visión analítica de algunas de las más populares.

Utilizar:

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

Es bastante fácil agregar algo de azúcar sintáctica que le permite a uno componer cuerdas sobre la marcha de una manera similar a un arroyo

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

Ahora puede agregar lo que quiera (siempre que un operador << (std::ostream& ..) se defina) strmake() y lo use en lugar de std::string .

Ejemplo:

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

ahora puede usar to_string(5)

Yo suelo:

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

Funciona en mis comstackdores de windows y linux g ++.

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

Si necesita conversión rápida de un número entero con un número fijo de dígitos a char * a la izquierda con ‘0’, este es un ejemplo conveniente:

 int n = 27; char s[8]; 

Si está convirtiendo un número de dos dígitos:

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

Si está convirtiendo un número de tres dígitos:

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

Si está convirtiendo un número de cuatro dígitos:

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

Y así sucesivamente hasta números de siete dígitos 🙂

Aquí hay otra manera fácil de hacerlo

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

sprintf es muy conocido para insertar cualquier dato en una cadena de formato requerido.

Puede convertir char * array en string como se muestra en la tercera línea.

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

Utiliza un tipo de algoritmo de contador para convertir a una cadena. Obtuve esta técnica de progtwigción de computadoras Commodore 64 . También es bueno para la progtwigción de juegos.

  • Toma el número entero y toma cada dígito ponderado por potencias de 10. Así que supongamos que el entero es 950.

    • Si el entero es igual o mayor a 100,000, restar 100,000 y boost el contador en la cadena en [“000000”];
      sigue haciéndolo hasta que no haya más números en la posición 100.000. Suelta otra potencia de diez

    • Si el entero es igual o mayor que 10,000, resta 10 000 y aumenta el contador en la cadena en [“000000”] + 1 posición;
      sigue haciéndolo hasta que no haya más números en la posición 10,000.

  • Suelta otra potencia de diez

  • Repita el patrón

Sé que 950 es demasiado pequeño para usarlo como ejemplo, pero espero que entiendas la idea.