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

¿Cuál es la forma más fácil de convertir de int a equivalente string en C ++. Soy consciente de dos métodos. ¿Existe alguna forma más sencilla?

(1)

int a = 10;
char *intStr = itoa(a);
string str = string(intStr);

(2)

int a = 10;
stringstream ss;
ss << a;
string str = ss.str();

preguntado el 08 de abril de 11 a las 01:04

Creo que los dos métodos que diste son buenas soluciones. depende del contexto en el que necesite 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 itoa 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 transmisiones son apropiadas. -

¿Cómo funciona la opción 1 para usted? Es mi entendimiento que itoa() toma tres parámetros. -

itoa será más rápido que el equivalente de transmisión. También hay formas de reutilizar el búfer de cadenas con el método itoa (evitando las asignaciones de montones si genera cadenas con frecuencia, por ejemplo, para algunos resultados numéricos que se actualizan rápidamente). Alternativamente, puede generar un streambuf personalizado para reducir algunos de los gastos generales de asignación, etc. La construcción del flujo en primer lugar tampoco es una empresa de bajo costo. -

@Pete: Una vez que empieces a preocuparte por cuál es más rápido, querrás mirar stackoverflow.com/questions/4351371/… -

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 está fuera a menos que esté usando algo más que GCC, que no es compatible con esta función. Si tiene C ++ 0x, siga lo que @Matthieu sugirió en su respuesta. Si ese no es el caso, opte por stringstream ya que es una característica bien soportada y su código debería ser compatible con todos los compiladores de C ++ que existen. Como alternativa, siempre puedes usar sprintf (). -

29 Respuestas

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

#include <string> 

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

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

auto s = std::to_string(42);

Nota: ver [cadena.conversiones] (21.5 in n3242)

respondido 14 mar '18, 20:03

to_string no es miembro de std fijar: stackoverflow.com/questions/12975341/… - paquet

O dependiendo de su compilador, simplemente establezca el estándar de lenguaje correcto: g++ -std=c++11 someFile.cc - Thomas M. Du Buisson

@Steve: se supone que es. Es miembro de std en cada compilador que conozco excepto uno. - Pato morando

@Matthiew M. Estoy usando lo mismo que sugieres, pero recibo este error: Error : No instance of overloaded function "std::to_string" matches the argument list estoy usando VS2010 c ++ - user2643530

@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

Actualización de C ++ 20: std :: formato sería la forma idiomática ahora.


Actualización de C ++ 17:

Retomando 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 de tipo agnóstica originalmente basada en macros (que se conserva a continuación) sin pasando 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 (C ++ 98):

Dado que "convertir ... a cadena" es un problema recurrente, siempre defino el SSTR () macro 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, ambas otras soluciones tienen un mejor rendimiento.

Respondido el 13 de junio de 21 a las 11:06

No estoy muy familiarizado con dynamic_cast pero estoy usando clang para compilar, por lo que se queja. Si simplemente omito el dynamic_cast luego se compila bien; que propósito tiene el dynamic_cast servir en este caso? Ya estamos creando un ostringstream, entonces ¿por qué lanzarlo? - Mathew

@Mathew: El enlace en mi respuesta conduce a una descripción detallada de cada parte de la construcción. Mientras nosotros creado a ostringstream, llamamos operator<<() en ella, que vuelve ostream & -- para cual .str() no está definido. Realmente me pregunto cómo el clang haría que esto funcionara sin el elenco (o por qué genera un error con él). Esta construcción se publica en muchos lugares, y la 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 que clang se oponga. - DevSolar

Solo vino a la fiesta por curiosidad y votó en contra. Razón: demasiados votos para una solución que no es elegante y probablemente lenta. 1. uso de macros. No frunzo el ceño sistemáticamente con 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 desprotegidas. (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 está implementada como espera. en cuyo caso debería utilizar boost :: polymorphic_downcast en su lugar. - v.oddou

@ v.oddou: Eres libre de criticar, por supuesto. Pero 1. no es válido: la macro es una sola declaración, do { } while( 0 ) no agregaría nada. Con 2. y 3. probablemente tengas razón: esto se podría hacer con un elenco estático, y tal vez uno de tus asistentes de plantillas podría crear una interfaz "mejor". Pero como dije, esto de ninguna manera es una invención de mí mismo. Mire a su alrededor, esta macro (¡macro!) Es bastante ubicua. Ese es un caso de POLA en sí mismo. Podría jugar un poco con esto para hacerlo más "aerodinámico". - DevSolar

@ v.oddou: Mira lo que encontré entre las cosas que nos trajo C ++ 17. :-) Espero que les guste la respuesta actualizada. - DevSolar

Yo suelo utilizar 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 aquí.

contestado el 31 de mayo de 19 a las 13:05

Antes de utilizar ss, necesitas ss.clear() eso. He visto resultados inesperados sin esta inicialización. - Balance de vida

@lifebalance: Nunca había visto tal comportamiento. - Rasoul

@lifebalance: no es necesario clear() un recién creado ostringstream objeto. clear() restablece los indicadores de error / eof y aún no se ha generado ninguna condición de error / eof. - Rémy Lebeau

@Rasoul NumberToString(23213.123) produce 23213.1 mientras std::to_string(23213.123) produce 23213.123000 ¿Qué pasa ahí? - Niño Killzone

@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 que este método comienza con un estado predeterminado. - xryl669

C ++ actual

A partir de C ++ 11, hay una std::to_string función sobrecargada para 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 los define como equivalentes a realizar la conversión con sprintf (utilizando el especificador de conversión que coincide con el tipo de objeto proporcionado, como %d por int), en un búfer de tamaño suficiente, luego creando un std::string del contenido de ese búfer.

C ++ antiguo

Para los compiladores más antiguos (anteriores a C ++ 11), probablemente la forma fácil más común envuelve esencialmente su segunda opción en una plantilla que generalmente se llama lexical_cast, como el 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 es compatible con otros lanzamientos (por ejemplo, en la dirección opuesta funciona igual de bien).

También tenga en cuenta que aunque Boost lexical_cast comenzó simplemente escribiendo a un stringstream, 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 verifica 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 puede convertir en un int (p.ej, 1234 tendría éxito, pero 123abc lanzaría).

Respondido el 26 de enero de 21 a las 03:01

Bien, prefiero la respuesta de Kevin, aunque muestra el espacio de nombres y la inclusión. Solo una pequeña queja. :) ¡Buen trabajo, aunque! - jason r mick

Yo diría que este es el camino a seguir si no tiene soporte para C ++ 11. - Alejandro Oh

Si tiene Boost instalado (que debería):

#include <boost/lexical_cast.hpp>

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

Respondido 08 Abr '11, 05:04

Acordado en la instalación de impulso. Creo que más de las veces uno formatearía la cadena. Para este propósito, prefiero boost :: formato, por ejemplo, formato ("% 02d", número) .str () - werner erasmus

Sería más fácil usar cadenas de cadenas:

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

#include <sstream>

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

contestado el 31 de mayo de 19 a las 13:05

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.

Respondido 08 Abr '11, 05:04

itoa() no es una función estándar! - Dibujante

@cartoonist: ¿Entonces qué es? - user541686

Esta función no está definida en ANSI-C y C ++. Por lo tanto, no es compatible con algunos compiladores como g ++. - Dibujante

Puedes 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::format_int de {mt} biblioteca para convertir un entero a std::string:

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

O una cuerda C:

fmt::format_int f(42);
f.c_str();

Este último no realiza ninguna asignación de memoria dinámica y es más del 70% más rápido que std::to_string sobre los puntos de referencia de Boost Karma. Ver Convertir cien millones de enteros a cadenas por segundo para más información.

Tenga en cuenta que ambos son seguros para subprocesos.

Diferente a la std::to_string, fmt::format_int no requiere C ++ 11 y funciona con cualquier compilador de C ++.

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

Respondido el 21 de diciembre de 20 a las 06:12

Tenía curiosidad por la afirmación de no tener ninguna asignación de memoria dinámica mientras permanecía seguro para subprocesos (reentrante), así que leí su código: el c_str() devuelve un puntero a un búfer declarado dentro del fmt::FormatInt class, por lo que el puntero devuelto no será válido en el punto y coma; consulte también stackoverflow.com/questions/4214153/lifetime-of-temporaries - Soren

Sí, el mismo comportamiento que con std::string::c_str() (de ahí el nombre). Si desea usarlo fuera de la expresión completa, construya un objeto FormatInt f(42); Entonces puedes usar f.c_str() sin peligro de ser destruido. - vitalidad

Me sale algo extraño cuando trato de 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

Esa es definitivamente la respuesta correcta a esta pregunta: código eficiente y estándar que no tiene estado. - xryl669

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.

Respondido el 07 de diciembre de 12 a las 15:12

Je, sí. Sin embargo, generalmente confío en snprintf () y amigos para cualquier cosa importante cuando manejo cadenas C. - Retroceso1986

@MatthieuM. Tu comentario prueba además que no lo eres. Si la salida se truncó debido a este límite, entonces 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. Por lo tanto, un valor de retorno de tamaño o más significa que la salida se truncó. Entonces lo llamas con un NULL y tamaño cero para obtener el tamaño de búfer necesario. - user1095108

@ user1095108: creo que te estás equivocando snprintf (nota la SNP prefijo) y sprintf (nota la SP prefijo). Se pasa el tamaño al primero y éste se cuida de que no se desborde, sin embargo, el segundo no conoce el tamaño del búfer y, por lo tanto, puede desbordarse. - Matthieu M.

La idea es llamar a un snprintf variante primero y una sprintf variante después de eso. Como ya se conoce el tamaño del búfer, llamar sprintf se vuelve completamente seguro. - user1095108

@ user1095108 Ah, sí. Si el primer búfer a 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

Primero incluye:

#include <string>
#include <sstream>

En segundo lugar, agregue el método:

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

Usa el método como este:

NumberToString(69);

or

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

Respondido 26 ago 14, 11:08

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

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

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

P.ej 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 tanto, recomiendo encarecidamente utilizar el std::to_string camino. Es más fácil y hace lo que esperas.

Actualizado (ver comentarios a continuación):

C ++ 17 proporciona std::to_chars como una alternativa independiente de la localidad de mayor rendimiento

Respondido 27 Abr '20, 08:04

Estoy de acuerdo en que este es un problema grave si necesita intercambiar datos. Desafortunadamente, también std::to_string usa la configuración regional actual (ver es.cppreference.com/w/cpp/string/basic_string/to_string , la sección 'Notas'). Casi todas las herramientas estándar (desde stringstreams hasta sprintf, pero también sscanf etc) están usando la configuración regional actual. No me di cuenta de esto hasta hace poco, cuando me golpeó con fuerza. Actualmente se usan cosas de cosecha propia, no es difícil de hacer. - berto bril

En el enlace anterior también se indica que C ++ 17 proporciona std :: to_chars como una alternativa independiente de la configuración regional de mayor rendimiento. - SíEseEsMiNombre

Desafortunadamente, estoy atascado con C ++ 11 durante los próximos años (ya es una gran mejora, afortunadamente). - berto bril

from_chars y to_chars serían perfectos, pero desafortunadamente no ofrecieron una variante wchar_t. - invitado128

Para C ++ 98, hay algunas opciones:

boost/lexical_cast

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

Programas de lexical_cast La plantilla 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, el lexical_cast la operación toma alrededor de 80 microsegundos (en mi máquina) en la primera conversión, y luego se acelera considerablemente si se hace de manera redundante.


itoa

Esta función no está definida en ANSI-C y no es 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 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ía si se usara 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;
}

Programas de stdio.h Es posible que el encabezado no sea necesario. En cuanto al tiempo de ejecución, el sprintf la operación toma alrededor de 40 microsegundos (en mi máquina) en la primera conversión, y luego se acelera considerablemente si se hace de manera redundante.


stringstream

Esta es la forma principal de la biblioteca 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. Utilizando ostringstream le dice específicamente al lector de su código que solo tiene la intención de usar el << operador, esencialmente. Esta función es todo lo que es particularmente necesario para convertir un número entero en 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, el ostringstream La operación toma alrededor de 71 microsegundos (en mi máquina) y luego se acelera considerablemente si se hace de manera 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 mirada analítica a algunas de las más populares.

Respondido el 20 de junio de 17 a las 15:06

Gracias por cuidarnos (usuarios de C ++ 98) - AB

@AB No puedo creer que todavía quedan usuarios de C ++ 98. - Kotauskas

@VladislavToncharov Cuando su trabajo consiste únicamente en dar soporte a equipos y códigos heredados, se deshace de las cosas viejas utilizando estándares de la industria más recientes. Hace un verano, estaba escribiendo código en Python 2.3. - Josué Detwiler

@JoshuaDetwiler Oh, me olvidé de eso, lo siento. - Kotauskas

C ++ 17 proporciona std::to_chars como una alternativa independiente de la configuración regional de mayor rendimiento.

Respondido el 29 de junio de 20 a las 08:06

Para aplicaciones de alto rendimiento, necesita esta y no la ruta de cadena. - invitado128

Es bastante fácil agregar algo de azúcar sintáctico que le permite a uno componer cadenas sobre la marcha de una manera similar 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 un operador << (std::ostream& ..) está definido para ello) a strmake() y utilícelo 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;
}

Respondido 03 Feb 18, 09:02

EDITADO. Si necesitas rápido conversión de un número entero con un número fijo de dígitos char * relleno a la izquierda con '0', este es el ejemplo de 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 n es 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é, 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.

respondido 16 nov., 19:17

¿Qué pasa con el orden de bytes? - shjeff

@shjeff gracias por el comentario, agregué una nota sobre endianidad 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 estrictas reglas de aliasing, gracias. - Alek

Uso:

#define convertToString(x) #x

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

Respondido el 16 de diciembre de 17 a las 22:12

Funciona solo con números literales, no evalúa el contenido variable, aunque es útil a veces. - Lobo

Derecha. Pero definitivamente útil en el momento maverick9888

Solo funciona en tiempo de compilación con números constantes literales, creo que el OP solicita una conversión dinámica, usando números enteros variables - En g. Gerardo Sánchez

Yo uso:

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.

contestado el 31 de mayo de 19 a las 13:05

Aquí hay otra forma fácil de hacerlo.

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 un char * matriz a una cadena como se muestra en la tercera línea.

contestado el 31 de mayo de 19 a las 13:05

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

contestado el 31 de mayo de 19 a las 13:05

¿Esencialmente usando qué? stringstream? - Pedro Mortensen

@PeterMortensen Mire con cuidado, es std::to_string() - Kotauskas

yo tengo using namespace std; :) - gonzalo garrido

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

Respondido 03 Jul 19, 12:07

¡Hola! ¿Podría agregar una explicación sobre por qué y cómo esto proporciona una respuesta a la pregunta? - otro nodo

int i = 255; std::string s = std::to_string(i);

En c ++, to_string () creará un objeto de cadena del valor entero representando el valor como una secuencia de caracteres.

Respondido el 17 de junio de 20 a las 22:06

Si bien este código puede resolver el problema del OP, es mejor incluir una explicación de cómo su código aborda el problema del OP. De esta manera, los futuros visitantes pueden aprender de su publicación y aplicarla a su propio código. SO no es un servicio de codificación, sino un recurso de conocimiento. Además, es más probable que se voten a favor las respuestas completas y de alta calidad. Estas características, junto con el requisito de que todas las publicaciones sean independientes, son algunas de las fortalezas de SO como plataforma, que la diferencia de los foros. Puede editar para agregar información adicional y / o complementar sus explicaciones con documentación fuente. - ysf

Usando el estándar simple encabezado stdio, puedes convertir el número entero correr en un búfer, así:

#include <stdio.h>
int main()
  {
  int x=23;
  char y[2]; //the output buffer
  sprintf(y,"%d",x);
  printf("%s",y)
  }

Recuerda cuidar tu tamaño del búfer según sus necesidades [el tamaño de salida de la cadena]

Respondido 07 Feb 21, 04:02

Uso:

#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;
    bool isNegative = num < 0;
    if(isNegative) num*=-1;

    do
    {
       char toInsert = (num % 10) + 48;
       numAsStr.insert(0, 1, toInsert);

       num /= 10;
    }while (num);
  
    return isNegative? numAsStr.insert(0, 1, '-') : numAsStr;
}

Respondido 22 Feb 21, 11:02

Falla completamente para n≤0 - Toby Speight

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

contestado el 31 de mayo de 19 a las 13:05

Gracias por este fragmento de código, que puede proporcionar una ayuda limitada a corto plazo. Una explicación adecuada mejoraría enormemente su valor a largo plazo mostrando el porqué Ésta 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 para agregar alguna explicación, incluidas las suposiciones que ha hecho. - Toby Speight

Falla completamente para n≤0 - Toby Speight

Agrega comentarios, explica tu respuesta, lee cómo responder. - aksen p

Si estás usando MFC, puedes usar CString:

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

Respondido el 25 de junio de 19 a las 19:06

Debe tener en cuenta que esta es una extensión exclusiva de Microsoft: msdn.microsoft.com/en-us/library/ms174288.aspx - jonnyjd

Me encanta la idea de CString :: Format (). Lamentablemente, solo es MS no portátil. - Nick

Actualicé mi respuesta para incluir la información de su comentario @JonnyJD, ya que sigo recibiendo votos negativos por ello 5 años después .. - girando

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

contestado el 31 de mayo de 19 a las 13:05

filtra memoria, -1 de mí - Paulm

Esto huele a saturación de búfer. - Kotauskas

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 utilizar to_string(5).

contestado el 31 de mayo de 19 a las 13:05

Si bien esta solución funciona, ¡se desaconseja mucho! Los nombres que comienzan con un guión bajo y una letra mayúscula están reservados para el compilador, nunca debe usarlos. Inyectando funciones en el std el espacio de nombres tampoco es algo que deba hacer. Además, no parece _MAX_INT_DIG es 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

¿Qué es _MAX_INT_DIG y por qué se duplica? - Paulm

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

contestado el 31 de mayo de 19 a las 13:05

Esto se mencionó en la pregunta y, lamentablemente, es bastante lento. - Kotauskas

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

  • Se toma el número entero y se toma cada dígito ponderado por potencias de 10. Así que suponga 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 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.

  • Deja caer otro poder de diez

  • Repite el patrón

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

contestado el 31 de mayo de 19 a las 13:05

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

No es la respuesta que estás buscando? Examinar otras preguntas etiquetadas or haz tu propia pregunta.