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

¿Cuál es la forma más fácil de convertir inta equivalente stringen C ++? Soy consciente de 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 atoiy, itoapero se expresa en términos de std::string.

#include <string> 

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

es, por lo tanto, el camino más corto que se me ocurre. Incluso puede omitir nombrar el tipo, usando la autopalabra clave:

auto s = std::to_string(42);

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

Comenzando 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 agnóstica de tipo originalmente basada en macro (preservada a continuación) sin pasar por la fealdad macro.

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

Respuesta original:

Como "convertir ... a cadena" es un problema recurrente, siempre defino la macro SSTR () en un encabezado central de mis fuentes 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, estas otras dos soluciones tienen un mejor rendimiento.

Usualmente uso el siguiente método:

#include <sstream>

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

Se describe en detalles 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 ventaja de esto es que también admite otros lanzamientos (por ejemplo, en la dirección opuesta funciona igual de bien).

También tenga en cuenta que, aunque Boost lexical_cast comenzó como escribir en un flujo de cadena y luego extraerlo de la transmisión, 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 flujo de cadena. En segundo lugar, ahora comprueba el resultado, por lo que (por ejemplo) si convierte de una cadena a una int, puede lanzar una excepción si la cadena contiene algo que no se pudo convertir a una int(por ejemplo, 1234tendría éxito, pero 123abcarrojaría) .

A partir de C ++ 11, hay una std::to_stringfunción sobrecargada para los tipos enteros, por lo que puede usar código como:

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

El estándar define estos como equivalentes a realizar la conversión con sprintf(utilizando el especificador de conversión que coincide con el tipo de objeto suministrado, como %dfor int), en un búfer de tamaño suficiente, y luego crear uno std::stringde los contenidos de ese búfer.

Si tiene instalado Boost (que debería):

#include <boost/lexical_cast.hpp>

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

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 puro C ++. Pero una pequeña modificación de lo que mencionaste

string s = string(itoa(a));

debería funcionar, y es bastante corto.

Puede usar std::to_stringdisponible en C ++ 11 como lo sugiere Matthieu M .:

std::to_string(42);

O, si el rendimiento es crítico (por ejemplo, si realiza muchas conversiones), puede usarlo fmt::format_intdesde la biblioteca {fmt} para convertir un entero a std::string:

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

O una cadena C:

fmt::format_int 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_stringen los puntos de referencia de Boost Karma. Consulte Conversión de entero a cadena rápida en C ++ para obtener más detalles.

Tenga en cuenta que ambos son seguros para subprocesos.

A diferencia std::to_string, fmt::format_intno requiere C ++ 11 y funciona con cualquier compilador de C ++.

Descargo de responsabilidad: soy el autor de la biblioteca {fmt}.

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

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

Use el método de esta manera:

NumberToString(69);

o

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

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

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

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

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

Por lo tanto, recomendaría encarecidamente utilizar el std::to_stringcamino. Es más fácil y hace lo que esperas.

Actualizado (ver comentarios a continuación) :

C ++ 17 proporciona std::to_charsuna alternativa independiente del entorno de mayor rendimiento

Para C ++ 98 , hay algunas opciones:

boost/lexical_cast

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

La lexical_castplantilla de función ofrece una forma conveniente y coherente para admitir 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 lexical_castoperación tarda 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 algunos compiladores la admiten.
- cplusplus.com

Esto significa que gcc/ g++no puedo 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 instalado Visual Studio, que según se informa puede compilar 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ía si se utilizara el formato en printf, pero en lugar de imprimirse, el contenido se almacena como una cadena C en el búfer señalado por cadena.
- 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 stdio.hencabezado puede no ser necesario. En cuanto al tiempo de ejecución, la sprintfoperación tarda unos 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 forma principal de la biblioteca C ++ de convertir enteros en cadenas, y viceversa. Hay funciones hermanas similares stringstreamque limitan aún más el uso previsto de la transmisión, como ostringstream. El uso ostringstreamle dice específicamente al lector de su código que solo tiene la intención de utilizar 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 <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 ostringstreamoperación tarda aproximadamente 71 microsegundos (en mi máquina) y luego se acelera considerablemente 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 esto ofrece una visión analítica de algunas de las más populares.

C ++ 17 proporciona std :: to_chars como una alternativa independiente del entorno de mayor rendimiento.

Es bastante fácil agregar un poco de azúcar sintáctica que le permite a uno componer cadenas sobre la marcha de una manera similar a una secuencia.

#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 desee (siempre que << (std::ostream& ..)se haya definido un operador ) 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;
}

EDITADO Si necesita una conversión rápida de un número entero con un número fijo de dígitos a char * rellenado a la izquierda con '0' , este es el ejemplo para arquitecturas little endian (todas x86, x86_64 y otras):

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. En este ejemplo nes un entero dado. Después de la conversión, se puede acceder a su representación de cadena como (char*)&s:

std::cout << (char*)&s << std::endl;

NOTA: Si lo necesita en orden de bytes big-endian, aunque no lo probé, pero aquí hay un ejemplo: para un número de tres dígitos es int32_t s = 0x00303030 | (n/100)<< 24 | (n/10%10)<<16 | (n%10)<<8;para números de cuatro dígitos (arco de 64 bits): int64_t s = 0x0000000030303030 | (n/1000)<<56 | (n/100%10)<<48 | (n/10%10)<<40 | (n%10)<<32;creo que debería funcionar.

Utilizar:

#define convertToString(x) #x

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

Yo suelo:

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 g ++ de Windows y Linux.

Aquí hay otra manera fácil de hacer

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

sprintf es bien conocido para insertar cualquier dato en una cadena del formato requerido.

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

Esto funcionó para mí

Mi código:

#include <iostream>
using namespace std;

int main()
{
    int n = 32;
    string s = to_string(n);
    cout << "string: " + s  << endl;
    return 0;
}

C ++ 11 introducido std::to_string()para tipos numéricos:

int n = 123; // Input, signed/unsigned short/int/long/long long/float/double
std::string str = std::to_string(n); // Output, std::string

Utilizar:

#include<iostream>
#include<string>

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

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

Si usa MFC , puede usar CString:

int a = 10;
CString strA;
strA.Format("%d", a);

char * bufSecs = new char[32];
char * bufMs = new char[32];
sprintf(bufSecs, "%d", timeStart.elapsed()/1000);
sprintf(bufMs, "%d", timeStart.elapsed()%1000);

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

Creo que usar stringstreames 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;
 }

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

• Tomas el número entero y tomas cada dígito ponderado por potencias de 10. Así que asume que el número entero es 950.

  • Si el número entero es igual o mayor que 100,000, reste 100,000 y aumente 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 otro poder de diez.

  • Si el número entero es igual o mayor que 10,000, 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.

• Suelta otro poder de diez

• Repite el patrón

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