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

Recogiendo una discusión con @v. oddou un par de años más tarde, C++17 finalmente ha entregado una forma de hacer la solución originalmente basada en macro agnóstica de tipo (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:

Desde " converting... para string " es un problema recurrente, siempre defino la macro SSTR() 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 ninguna inclusión de terceros (si no puede usar Boost lexical_cast<>); sin embargo, ambas soluciones tienen un mejor rendimiento.

Normalmente 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 detalle aquí.

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

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

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

También tenga en cuenta que aunque Boost lexical_cast comenzó simplemente escribiendo en un flujo de cadenas, luego extrayendo de nuevo del flujo, ahora tiene un par de adiciones. Primero de se han añadido especializaciones para bastantes tipos, por lo que para muchos tipos comunes, es sustancialmente más rápido que usar un flujo de cadena. 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 se podría convertir a un int (por ejemplo, 1234 tendría éxito, pero 123abc lanzarí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, luego creando un std::string del contenido de ese búfer.

Si tiene Boost instalado (que debería):

#include <boost/lexical_cast.hpp>

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

¿No sería más fácil usar stringstreams?

#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 hacer una función:

#include <sstream>

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

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

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 incluya:

#include <string>
#include <sstream>

En segundo lugar añadir 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!."

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

std::to_string(42);

O, si el rendimiento es crítico (por ejemplo, si realiza muchas conversiones), puede usar fmt::FormatInt desde la biblioteca en formato C++ 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 hace 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. Véase Conversión rápida de entero a cadena en C++ para más detalles.

A diferencia std::to_string, fmt::FormatInt no requiere C++11 y funciona con cualquier compilador 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!

Véase http://www.cplusplus.com/reference/ostream/ostream/operator%3C%3C / donde dice que operator<< inserta la salida formateada.

Dependiendo de su configuración regional actual, un entero mayor que 3 dígitos, podría convertirse en una cadena de 4 dígitos, agregando un separador de miles adicional.

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 todo.

Así que recomiendo encarecidamente usar la forma std::to_string. Es más fácil y hace lo que esperas.

Para C++98, hay algunas opciones:

boost/lexical_cast

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

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

#include "boost/lexical_cast.hpp"
#include <string>

int main() {
    int x = 5;
    std::string x_str = boost::lexical_cast<std::string>(x);
    return 0;
}

En cuanto al tiempo de ejecución, la operación lexical_cast tarda unos 80 microsegundos (en mi máquina) en la primera conversión, y luego se acelera considerablemente después si se hace redundantemente.

itoa

Esta función no está definida en ANSI-C y no es parte de C++, pero es soportada por algunos compiladores.
-- cplusplus.com

Esto significa que gcc/g++ no se puede compilar código usando itoa.

#include <stdlib.h>

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 Visual Studio instalado, que es según se informa capaz de compilar itoa.

sprintf

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

Compone una cadena con el mismo texto que se imprimirá si el formato de printf, pero en lugar de ser impreso, el contenido se almacena como una cadena C en el buffer apuntado por str.
-- cplusplus.com

#include <stdio.h>

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 sprintf toma alrededor de 40 microsegundos (en mi máquina) en la primera conversión, y luego se acelera considerablemente después si se hace redundantemente.

stringstream

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

#include <sstream>
#include <string>

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 unos 71 microsegundos (en mi máquina), y luego se acelera considerablemente si se hace redundantemente, pero no tanto como las funciones anteriores.

Por supuesto, hay otras opciones, e incluso puede envolver una de estas en su propia función, pero esto ofrece una mirada analítica a algunos de los más populares.

Uso:

#define convertToString(x) #x

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

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

#include <string>
#include <sstream>

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

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

Ejemplo:

#include <iostream>

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 puedes usar to_string(5)

Utilizo:

int myint = 0;
long double myLD = 0.0;

string myint_str = static_cast<ostringstream*>( &(ostringstream() << myint) )->str();
string myLD_str = static_cast<ostringstream*>( &(ostringstream() << myLD) )->str();

Funciona en mis compiladores 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<iostream>
#include<string>
#include<string.h>


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 una conversión rápida de un entero con un número fijo de dígitos a char * left-padded 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 hacer

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

Sprintf es bien conocido por insertar cualquier dato en una cadena de formato requerido .

Puede convertir la matriz char * en cadena como se muestra en la tercera línea.

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

Creo que usar stringstream es bastante fácil.

 string toString(int n)
 {
   stringstream ss(n);
   ss << n;
   return ss.str();
 }

 int main()
 {
    int n;
    cin>>n;
    cout<<toString(n)<<endl;
    return 0;
 }

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

• Se toma el entero y se toma cada dígito que está ponderado por potencias de 10. Así que supongamos que el entero es 950.

  • Si el entero es igual o mayor que 100.000 entonces reste 100.000 y aumente el contador en la cadena en ["000000"];
    sigue haciéndolo hasta que no haya más números posición 100.000. Caer otra potencia de diez

  • Si el entero es igual o mayor que 10.000 entonces reste 10.000 y aumente 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.

• Caer otra potencia de diez

• Repetir el patrón

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