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

int to string c++

Question

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

Answer 1

Aquí hay otra manera fácil de hacer

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

sprintf es bien conocido para insertar datos en una cadena de formato requerido.

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

Answer 2

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

Answer 3

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 <string> 

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

Por lo tanto, es el camino más corto que se me ocurre. Incluso puede omitir el nombre del tipo, usando la palabra clave auto :

auto s = std::to_string(42);

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

Answer 4

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

Answer 5

Es bastante fácil agregar un poco de azúcar sintáctico que permite componer cuerdas sobre la marcha de una manera parecida a una 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 desee (siempre que se haya definido un operador << (std::ostream& ..) ) para strmake() y usarlo en lugar de std::string .

Ejemplo:

#include <iostream>

int main() {
    std::string x =
      strmake() << "Current time is " << 5+5 << ":" << 5*5 << " GST";
    std::cout << x << std::endl;
}

Answer 6

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.

Answer 7

Primero incluye:

#include <string>
#include <sstream>

Segundo agregar el método:

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

Utilice el método de esta manera:

NumberToString(69);

o

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

Answer 8

Probablemente, la forma fácil más común encierra esencialmente su segunda opción en una plantilla llamada lexical_cast , como la de Boost , de modo que su código tenga este aspecto:

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

Un detalle de esto es que también admite otros modelos (por ejemplo, en la dirección opuesta también funciona).

También tenga en cuenta que aunque Boost lexical_cast comenzó simplemente escribiendo en una cadena de caracteres y luego extrayéndolo, 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 una cadena de caracteres. En segundo lugar, ahora verifica el resultado, así que (por ejemplo) si convierte de una cadena a un int , puede lanzar una excepción si la cadena contiene algo que no se puede convertir en una int (por ejemplo, 1234 tendría éxito, pero 123abc tirarí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 define estos como equivalentes a hacer la conversión con sprintf (utilizando 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 una std::string de contenidos de ese buffer.

Answer 9

Puede usar std::to_string disponible 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 usar fmt::FormatInt de la biblioteca de formatos C ++ para convertir un número 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 10 veces más rápido que std::to_string en los puntos de referencia de Boost Karma. Consulte Conversión rápida de enteros a cadenas en C ++ para obtener más detalles.

A diferencia de 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 en formato C ++.

Answer 10

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

Dado que "convertir ... a cadena" 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 ningún tipo de std::to_string de terceros (si no puede usar Boost lexical_cast<> ); Sin embargo, estas otras dos soluciones tienen un mejor rendimiento.

Answer 11

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

Answer 12

Si tienes instalado Boost (que deberías):

#include <boost/lexical_cast.hpp>

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

Answer 13

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 detalle here .

Answer 14

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

• Tomas el entero y tomas cada dígito ponderado por potencias de 10. Entonces, asume que el 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 otra potencia 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 otra potencia de diez.

• Repetir patrón

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

Answer 15

Utilizando CString :

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

Answer 16

Utilizar:

#define convertToString(x) #x

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

Answer 17

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 windows y linux g ++.

Answer 18

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

Answer 19

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 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 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 forma parte de C ++, pero es compatible con algunos compiladores.
- cplusplus.com

Esto significa que gcc / g++ no 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 instalado Visual Studio, que al reportedly puede compilar en itoa .

sprintf

sprintf es una función de biblioteca estándar de 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 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 si se realiza de forma redundante.

stringstream

Esta es la forma principal de la biblioteca C ++ de convertir enteros en cadenas, y viceversa. Existen funciones hermanas similares al stringstream de stringstream que limitan aún más el uso previsto del flujo, como ostringstream . El uso de ostringstream específicamente le dice al lector de su código que solo pretende usar el operador << , esencialmente. Esta función es todo lo que es particularmente necesario para convertir un número 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 lo que respecta al tiempo de ejecución, la operación de ostringstream toma 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 estas en su propia función, pero esto ofrece una visión analítica de algunas de las más populares.

Answer 20

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

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

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

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

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

Answer 21

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

Answer 22

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

Answer 23

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

Answer 24

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)

Answer 25

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