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

1574

¿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();
Nemo
fuente
44
Creo que ambos métodos que diste son buenas soluciones. depende del contexto en el que necesites hacerlo. Si ya está trabajando con transmisiones, por ejemplo, leyendo o escribiendo un archivo, entonces su segundo método es el mejor. Si necesita pasar un int como una cadena a un argumento de función, entonces podría ser una manera fácil. Pero la mayoría de las veces, la conversión de int a string ocurre cuando se trata de archivos, por lo que las secuencias son apropiadas.
Charles Brunet
41
¿Cómo funciona la opción 1 incluso para ti? Es mi entendimiento que itoa()toma tres parámetros.
b1nary.atr0phy
1
itoa será más rápido que el flujo equivalente. También hay formas de reutilizar el búfer de cadenas con el método itoa (evitando las asignaciones de montón si genera cadenas con frecuencia, por ejemplo, para algunos resultados numéricos que se actualizan rápidamente). Alternativamente, puede generar un flujo de flujo personalizado para reducir parte de la sobrecarga de asignación, etc. Construir el flujo en primer lugar tampoco es una empresa de bajo costo.
Pete
66
@Pete: Una vez que empieces a preocuparte por cuál es más rápido, querrás ver stackoverflow.com/questions/4351371/…
Ben Voigt
20
Tenga en cuenta que itoa () no es parte del estándar y, por lo tanto, usarlo hace que su código no sea portátil ya que no todos los compiladores lo admiten. Para Linux, seguramente estará fuera a menos que esté usando algo más que GCC, que no admite esta función. Si tiene C ++ 0x, vaya con lo que @Matthieu ha sugerido en su respuesta. Si ese no es el caso, vaya con stringstream ya que es una característica bien soportada y su código debe ser compatible con todos los compiladores de C ++. Como alternativa, siempre puedes usar sprintf ().
rbaleksandar

Respuestas:

2102

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 )

Matthieu M.
fuente
199
to_stringno es miembro de la stdsolución: stackoverflow.com/questions/12975341/…
Ben
36
O dependiendo de su compilador, simplemente establezca el estándar de idioma correcto:g++ -std=c++11 someFile.cc
Thomas M. DuBuisson
12
@ Steve: se supone que debe ser. Es miembro de stdtodos los compiladores que conozco, excepto uno.
Mooing Duck
55
@Matthiew M. Estoy usando lo mismo que usted sugiere, pero recibo este error: Error : No instance of overloaded function "std::to_string" matches the argument list estoy usando VS2010 c ++
19
@Flying: en VS2010 debe convertir explícitamente el entero de conversión a uno de los siguientes tipos [_Longlong, _ULonglong, long double]; es decir:string s = to_string((_ULonglong)i);
Zac
184

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.

DevSolar
fuente
2
No estoy muy familiarizado, dynamic_castpero estoy usando clang para compilar, por lo que se queja. Si solo omito el, dynamic_castentonces se compila bien; ¿Para qué sirve el dynamic_casten este caso? Ya estamos creando un ostringstream, así que ¿por qué lanzarlo?
Mateo
2
@Mathew: El enlace en mi respuesta conduce a una descripción detallada de cada parte de la construcción. Mientras creamos un ostringstream, lo llamamos operator<<(), lo que devuelve ostream &, para lo cual .str()no está definido. Realmente me pregunto cómo Clang haría que esto funcione sin el elenco (o por qué genera un error con él). Este constructo se publica en muchos lugares, y lo he usado durante más de una década en muchos compiladores diferentes, incluidos MSVC, GCC y XLC, por lo que estoy bastante sorprendido de escucharlo.
DevSolar
55
Solo vine a la fiesta por curiosidad, y voté en contra. Motivo: demasiados votos para una solución poco elegante y probablemente lenta. 1. uso macro. No frunzo el ceño sistemáticamente en ninguna macro, pero esta es demasiado corta, y los clientes finales siempre temen la repetición del argumento, además del miedo a las macros multilíneas sin protección. (no protegido por do {} while (0)) 2. dynamic_cast. parece que solo necesita un static_cast aquí, a menos que quiera afirmar que la biblioteca de hecho está implementada como espera. en cuyo caso deberías usar boost :: polymorphic_downcast en su lugar.
v.oddou
2
@ v.oddou: Eres libre de criticar, por supuesto. Pero 1. no es válido: la macro es una declaración única, do { } while( 0 )no agregaría nada. Con 2. y 3. probablemente obtuviste un punto: esto podría hacerse con un reparto estático, y quizás uno de los asistentes de plantillas podría tener una interfaz "más agradable". Pero como dije, esto de ninguna manera es un invento mío. Mire a su alrededor, esta macro (¡macro!) Es bastante ubicua. Ese es un caso de POLA en sí mismo. Podría jugar con esto un poco para hacerlo más "aerodinámico".
DevSolar
1
@ v.oddou: Mira lo que encontré entre las cosas que C ++ 17 nos trajo. :-) Espero que les guste la respuesta actualizada.
DevSolar
109

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

Rasoul
fuente
2
Antes de usar ss, lo necesitas ss.clear(). He visto resultados inesperados sin esta inicialización.
Lifebalance
14
@lifebalance: nunca he visto tal comportamiento.
Rasoul
18
@lifebalance: no necesita clear()un ostringstreamobjeto recién creado . clear()restablece los indicadores de error / eof y todavía no se ha generado ninguna condición de error / eof.
Remy Lebeau
2
@Rasoul NumberToString(23213.123)produce 23213.1mientras std::to_string(23213.123)produce 23213.123000¿Qué sucede allí?
Killzone Kid
1
@KillzoneKid Esto se debe a que std 'ostream tiene estado (esto significa que cualquier cambio de estado anterior se mantiene, como el número de dígitos decimales) mientras este método comienza con un estado predeterminado.
xryl669
85

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.

Jerry Coffin
fuente
2
Agradable, prefiero la respuesta de Kevin, sin embargo, ya que muestra la inclusión y el espacio de nombres. Solo una pequeña queja. :) Buen trabajo, sin embargo!
Jason R. Mick
44
Yo diría que este es el camino a seguir si no tiene soporte para C ++ 11.
Alex
40

Si tiene instalado Boost (que debería):

#include <boost/lexical_cast.hpp>

int num = 4;
std::string str = boost::lexical_cast<std::string>(num);
Kevin
fuente
44
Acordado en la instalación de impulso. Creo que más de una vez se formatearía la cadena. Para este propósito, prefiero boost :: format ej. Format ("% 02d", número) .str ()
Werner Erasmus
28

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

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.

usuario541686
fuente
55
itoa()¡No es una función estándar!
dibujante
44
@cartoonist: Entonces, ¿qué es?
user541686
20
Esta función no está definida en ANSI-C y C ++. Por lo tanto, no es compatible con algún compilador como g ++.
dibujante
17

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

vitaut
fuente
2
Tenía curiosidad acerca de la afirmación de no tener ninguna asignación de memoria dinámica mientras permanecía seguro para los hilos (reentrante), así que leí su código, que c_str()devuelve un puntero a un búfer declarado dentro de la fmt::FormatIntclase, por lo que el puntero devuelto no será válido en el punto y coma - vea también stackoverflow.com/questions/4214153/lifetime-of-temporaries
Soren
1
Sí, el mismo comportamiento que con std::string::c_str()(por lo tanto, el nombre). Si desea usarlo fuera de la expresión completa, construya un objeto. FormatInt f(42);Luego puede usarlo f.c_str()sin peligro de que sea destruido.
Vitaut
1
Me sale algo extraño cuando intento convertir de int a string usando std :: to_string (num). Si almaceno el resultado en una variable e intento acceder a él como stringNum [1] o stringNum [n] a medida que n aumenta, obtengo basura.
user8951490
1
Esa es definitivamente la respuesta correcta a esta pregunta: código eficiente y estándar que no tiene estado.
xryl669
16

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.

Retroceso1986
fuente
1
Je, si. Sin embargo, generalmente confío en snprintf () y amigos para cualquier cosa de importancia cuando manejo cadenas C.
Throwback1986
1
@MatthieuM. Tu comentario prueba más, que no lo eres. Si la salida se trunca debido a este límite, el valor de retorno es el número de caracteres (excluyendo el byte nulo de terminación) que se habrían escrito en la cadena final si hubiera suficiente espacio disponible. Así, un valor de retorno de tamaño o más significa que la salida se truncó. Entonces lo llamas con un NULLtamaño cero para obtener el tamaño de búfer necesario.
user1095108
2
@ user1095108: Creo que se está equivocando snprintf(tenga en cuenta el prefijo SNP ) y sprintf(tenga en cuenta el prefijo SP ). Se pasa el tamaño al primero, y se cuida de no desbordarse, sin embargo, el segundo no conoce el tamaño del búfer y, por lo tanto, puede desbordarse.
Matthieu M.
1
La idea es llamar a una snprintfvariante primero y una sprintfvariante después de eso. Como el tamaño del búfer se conoce para entonces, las llamadas se sprintfvuelven completamente seguras.
user1095108
1
@ user1095108 Ah, sí. Si el primer búfer para snprintf es insuficiente, el valor de retorno le indica qué sería suficiente. Todavía usaría snprintf para la segunda llamada, porque confiar en las implementaciones de sprintf y snprintf para que coincidan es innecesariamente peligroso.
mabraham
11

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!."
Alex
fuente
10

¡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

YesThatIsMyName
fuente
2
Estoy de acuerdo en que este es un problema grave si necesita intercambiar datos. Desafortunadamente, también std::to_stringusa la configuración regional actual (consulte en.cppreference.com/w/cpp/string/basic_string/to_string , la sección 'Notas'). Casi todas las herramientas estándar (desde cadenas de secuencias hasta sprintf, pero también sscanfetc.) están utilizando la configuración regional actual. No era consciente de esto hasta hace poco, cuando me golpeó duro. Actualmente usando cosas de cosecha propia, no es difícil de hacer.
Bert Bril
En el enlace anterior también se afirma que C ++ 17 proporciona std :: to_chars como una alternativa independiente del entorno de mayor rendimiento.
YesThatIsMyName
Desafortunadamente, estoy atascado con C ++ 11 para el (los) año (s) que viene (una suerte ya, por suerte).
Bert Bril
1
from_chars y to_chars serían perfectos pero desafortunadamente no ofrecieron una variante wchar_t.
gast128
8

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.

Joshua Detwiler
fuente
Gracias por cuidarnos (usuarios de C ++ 98)
A. B
@AB No puedo creer que todavía quedan usuarios de C ++ 98.
Kotauskas
@VladislavToncharov Cuando su trabajo es únicamente para admitir equipos y códigos heredados, se deshilacha de las cosas viejas utilizando estándares industriales más recientes. Hace un verano, estaba escribiendo código en Python 2.3.
Joshua Detwiler
@JoshuaDetwiler Oh, se olvidó de eso, lo siento.
Kotauskas
4

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


fuente
3

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;
}
AndreyS Scherbakov
fuente
2

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.

Alek
fuente
2
¿Qué pasa con el orden de bytes?
shjeff
¿No es este comportamiento indefinido debido al alias de puntero?
dgnuff
1
@shjeff gracias por el comentario, agregué una nota sobre endianness a la respuesta.
Alek
@dgnuff gracias por señalar esto, aunque no he tenido problemas con esto, tienes razón. Modifiqué ligeramente la respuesta para que cumpla con las Reglas de Aliasing estrictas, gracias.
Alek
1

Utilizar:

#define convertToString(x) #x

int main()
{
    convertToString(42); // Returns const char* equivalent of 42
}
maverick9888
fuente
3
Funciona solo con números literales, no evalúa el contenido variable, aunque a veces es útil.
Lobo
Derecha. Pero definitivamente útil a la vez
maverick9888
1
Solo funciona en tiempo de compilación con números de constantes literales, creo que el OP solicita una conversión dinámica, usando enteros variables
Ing. Gerardo Sánchez
0

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.

J_C
fuente
0

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.

Natesh Bhat
fuente
0

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;
}
Gonçalo Garrido
fuente
¿Esencialmente usando qué? stringstream?
Peter Mortensen
@PeterMortensen Mire cuidadosamente, esstd::to_string()
Kotauskas
tengo using namespace std;:)
Gonçalo Garrido
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
Kamrujjaman Joy
fuente
44
¡Hola! ¿Podría agregar una explicación sobre por qué y cómo esto proporciona una respuesta a la pregunta?
anothernode
0

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;
}
Tayyab Mazhar
fuente
1
Completamente falla para n≤0
Toby Speight
-1
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;
}
Abdullah Abdelmonem
fuente
1
Gracias por este fragmento de código, que podría proporcionar una ayuda limitada a corto plazo. Una explicación adecuada mejoraría en gran medida su valor a largo plazo al mostrar por qué esta es una buena solución al problema y la haría más útil para futuros lectores con otras preguntas similares. Por favor, editar su respuesta a añadir un poco de explicación, incluyendo los supuestos realizados.
Toby Speight
Completamente falla para n≤0
Toby Speight
Agregue comentarios, explique su respuesta, lea cómo responder .
Aksen P
-1

Si usa MFC , puede usar CString:

int a = 10;
CString strA;
strA.Format("%d", a);
Tur1ng
fuente
8
Debe tener en cuenta que esta es una extensión exclusiva de Microsoft: msdn.microsoft.com/en-us/library/ms174288.aspx
JonnyJD
1
Me encanta la idea de CString :: Format (). Desafortunadamente es solo MS no portátil.
Nick
1
He actualizado mi respuesta para incluir la información de su comentario @JonnyJD, ya que me siguen dando downvoted para que 5 años después ..
Tur1ng
-2
char * bufSecs = new char[32];
char * bufMs = new char[32];
sprintf(bufSecs, "%d", timeStart.elapsed()/1000);
sprintf(bufMs, "%d", timeStart.elapsed()%1000);
usuario2047065
fuente
12
pierde memoria, -1 de mí
Paul
Esto huele a desbordamiento de búfer.
Kotauskas
-2
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).

Peter Mortensen
fuente
10
Si bien esta solución funciona, ¡se desaconseja mucho! Los nombres que comienzan con guión bajo y una letra mayúscula están reservados para el compilador, nunca debe usarlos. Inyectar funciones en el stdespacio de nombres tampoco es algo que deba hacer. Además, no parece que _MAX_INT_DIGsea ​​una macro estándar, por lo que si se define incorrectamente, este código tiene el gran potencial de inducir un comportamiento indefinido. -1
iFreilicht
66
¿Qué es _MAX_INT_DIG y por qué se duplica?
Paul
-2

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;
 }
rashedcs
fuente
Esto fue mencionado en la pregunta, y desafortunadamente es bastante lento.
Kotauskas
-3

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.

AlmiranteSmith
fuente
No es muy útil describir un algoritmo, en lugar de mostrar un ejemplo en código.
cdeerinck