referencia - ¿Alternativa a itoa() para convertir un entero a la cadena C++?

referencia a itoa sin definir

Question

Esta pregunta ya tiene una respuesta aquí:

• La forma más fácil de convertir int a cadena en C ++ 22 respuestas

Me preguntaba si había una alternativa a itoa() para convertir un entero en una cadena porque cuando lo ejecuto en Visual Studio recibo advertencias, y cuando intento construir mi programa bajo Linux, aparece un error de compilación.

Answer 1

Arqueología

itoa era una función auxiliar no estándar diseñada para complementar la función estándar atoi, y probablemente ocultando un sprintf (la mayoría de sus características se pueden implementar en términos de sprintf): http://www.cplusplus.com/reference/clibrary/cstdlib/itoa.html

La forma C

Use sprintf. O snprintf. O cualquier herramienta que encuentres.

A pesar de que algunas funciones no están en el estándar, como se menciona correctamente por "onebyone" en uno de sus comentarios, la mayoría de los compiladores le ofrecerán una alternativa (por ejemplo, Visual C ++ tiene su propio _snprintf, puede escribir def a snprintf si lo necesita).

La forma C ++.

Use las secuencias de C ++ (en el caso actual std :: stringstream (o incluso el std :: strstream en desuso, como propuso Herb Sutter en uno de sus libros, porque es algo más rápido).

Conclusión

Estás en C ++, lo que significa que puedes elegir la forma que quieras:

• La forma más rápida (es decir, la forma C), pero debe asegurarse de que el código sea un cuello de botella en su aplicación (las optimizaciones prematuras son malas, etc.) y que su código esté encapsulado de forma segura para evitar el riesgo de sobrepasar el búfer.

• La forma más segura (es decir, el modo C ++), si conoce esta parte del código no es crítico, así que es mejor asegurarse de que esta parte del código no se rompa en momentos aleatorios porque alguien confundió un tamaño o un puntero (lo cual sucede en la vida real, como ... ayer, en mi computadora, porque alguien pensó que era "genial" usar el modo más rápido sin realmente necesitarlo).

Answer 2

Aquí hay una versión C de itoa, con algunas condiciones:

char* custom_itoa(int i)
{
static char output[24]; // 64-bit MAX_INT is 20 digits
char* p = &output[23];
for(*p--=0;i;i/=10) *p--=i%10+0x30;
return ++p;
}

• Esto no maneja números negativos
• Actualmente, esto no maneja números mayores a 23 caracteres en forma decimal.
• no es seguro para subprocesos
• el valor de retorno se borrará / se dañará tan pronto como se vuelva a llamar a la función.
  Entonces, si vas a mantener el valor de retorno, necesitas strcpy a un buffer separado.

Answer 3

Asigne una cadena de longitud suficiente, luego use snprintf.

Answer 4

Detrás de escena, lexical_cast hace esto:

std::stringstream str;
str << myint;
std::string result;
str >> result;

Si no desea "impulsar" para esto, entonces usar lo anterior es una buena solución.

Answer 5

En C ++ 11 puedes usar std::to_string :

#include <string>
std::string s = std::to_string(5);

Si está trabajando con anterioridad a C ++ 11, podría usar flujos de C ++:

#include <sstream>
int i = 5;
std::string s;
std::stringstream out;
out << i;
s = out.str();

Tomado de http://notfaq.wordpress.com/2006/08/30/c-convert-int-to-string/

Answer 6

En plataformas derivadas de Windows CE, no hay iostream s por defecto. La manera de ir allí es preferible con la familia _itoa<> , por lo general, _itow<> (ya que la mayoría de las cadenas son Unicode allí de todos modos).

Answer 7

En realidad, puede convertir cualquier cosa en una cadena con una función de plantilla ingeniosamente escrita. Este ejemplo de código usa un bucle para crear subdirectorios en un sistema Win-32. El operador de concatenación de cadenas, operador +, se usa para concatenar una raíz con un sufijo para generar nombres de directorio. El sufijo se crea convirtiendo la variable de control de bucle, i, en una cadena de C ++, utilizando la función de plantilla, y concatenándola con otra cadena.

//Mark Renslow, Globe University, Minnesota School of Business, Utah Career College
//C++ instructor and Network Dean of Information Technology
#include <cstdlib>
#include <iostream>
#include <string>
#include <sstream> // string stream
#include <direct.h>
using namespace std;
string intToString(int x)
{
/**************************************/
/* This function is similar to itoa() */
/* "integer to alpha", a non-standard */
/* C language function. It takes an */
/* integer as input and as output, */
/* returns a C++ string. */
/* itoa() returned a C-string (null- */
/* terminated) */
/* This function is not needed because*/
/* the following template function */
/* does it all */
/**************************************/
string r;
stringstream s;
s << x;
r = s.str();
return r;
}
template <class T>
string toString( T argument)
{
/**************************************/
/* This template shows the power of */
/* C++ templates. This function will */
/* convert anything to a string! */
/* Precondition: */
/* operator<< is defined for type T */
/**************************************/
string r;
stringstream s;
s << argument;
r = s.str();
return r;
}
int main( )
{
string s;
cout << "What directory would you like me to make?";
cin >> s;
try
{
mkdir(s.c_str());
}
catch (exception& e)
{
cerr << e.what( ) << endl;
}
chdir(s.c_str());
//Using a loop and string concatenation to make several sub-directories
for(int i = 0; i < 10; i++)
{
s = "Dir_";
s = s + toString(i);
mkdir(s.c_str());
}
system("PAUSE");
return EXIT_SUCCESS;
}

Answer 8

Escribí esta función thread-safe hace algún tiempo, y estoy muy contento con los resultados y siento que el algoritmo es liviano y delgado, con un rendimiento que es aproximadamente 3 veces la función estándar de MSVC _itoa ().

Aquí está el enlace. Optimal Base-10 solo la función itoa ()? El rendimiento es al menos 10 veces mayor que el de sprintf (). El punto de referencia es también la prueba de control de calidad de la función, de la siguiente manera.

start = clock();
for (int i = LONG_MIN; i < LONG_MAX; i++) {
if (i != atoi(_i32toa(buff, (int32_t)i))) {
printf("/nError for %i", i);
}
if (!i) printf("/nAt zero");
}
printf("/nElapsed time was %f milliseconds", (double)clock() - (double)(start));

Hay algunas sugerencias tontas sobre el uso del almacenamiento de la persona que llama que dejaría el resultado flotando en algún lugar en un búfer en el espacio de direcciones de la persona que llama. Ingnóralos. El código que enumeré funciona perfectamente, como lo demuestra el código de referencia / QA.

Creo que este código es lo suficientemente delgado como para usarlo en un entorno incrustado. YMMV, por supuesto.

Answer 9

La mayoría de las sugerencias anteriores técnicamente no son C ++, son soluciones en C.

Mire en el uso de std::stringstream .

Answer 10

La mejor respuesta, IMO, es la función proporcionada aquí:

http://www.jb.man.ac.uk/~slowe/cpp/itoa.html

Imita la función no ANSI proporcionada por muchas librerías.

char* itoa(int value, char* result, int base);

También es muy rápido y se optimiza bien por debajo de -O3, y la razón por la que no estás usando c ++ string_format () ... o sprintf es porque son demasiado lentos, ¿no?

Answer 11

Podemos definir nuestra propia función iota en c ++ como:

string itoa(int a)
{
string ss=""; //create empty string
while(a)
{
int x=a%10;
a/=10;
char i=''0'';
i=i+x;
ss=i+ss; //append new character at the front of the string!
}
return ss;
}

No te olvides de #include <string> .

Answer 12

Prueba sprintf ():

char str[12];
int num = 3;
sprintf(str, "%d", num); // str now contains "3"

sprintf () es como printf () pero muestra una cadena.

Además, como mencionó Parappa en los comentarios, es posible que desee utilizar snprintf () para evitar que se produzca un desbordamiento del búfer (donde el número que está convirtiendo no se ajusta al tamaño de su cadena). Funciona así:

snprintf(str, sizeof(str), "%d", num);

Answer 13

Pruebe Boost.Format o FastFormat , ambas bibliotecas C ++ de alta calidad:

int i = 10;
std::string result;

Con Boost.Format

result = str(boost::format("%1%", i));

o FastFormat

fastformat::fmt(result, "{0}", i);
fastformat::write(result, i);

Obviamente, ambos hacen mucho más que una simple conversión de un solo entero

Answer 14

Si está interesado en un método de conversión de enteros rápido y seguro a cadenas de caracteres y no está limitado a la biblioteca estándar, puedo recomendar el método FormatInt de la biblioteca de Formato C ++ :

fmt::FormatInt(42).str(); // convert to std::string
fmt::FormatInt(42).c_str(); // convert and get as a C string
// (mind the lifetime, same as std::string::c_str())

De acuerdo con el número entero de puntos de referencia de conversión de cadenas de Boost Karma, este método es varias veces más rápido que sprintf o std::stringstream . Es incluso más rápido que el propio int_generator de Boost Karma como lo confirmó un punto de referencia independiente .

Descargo de responsabilidad: soy el autor de esta biblioteca.

Answer 15

Tenga en cuenta que todos los métodos de stringstream pueden implicar bloquear el uso del objeto de configuración regional para el formateo. Puede ser algo de lo que tenga cuidado si usa esta conversión de varios hilos ...

Mira aquí para más.

Answer 16

Yo uso estas plantillas

template <typename T> string toStr(T tmp)
{
ostringstream out;
out << tmp;
return out.str();
}
template <typename T> T strTo(string tmp)
{
T output;
istringstream in(tmp);
in >> output;
return output;
}

Answer 17

С ++ 11 finalmente resuelve esto proporcionando std::to_string . También boost::lexical_cast es una herramienta útil para compiladores antiguos.

Answer 18

boost::lexical_cast funciona bastante bien.

#include <boost/lexical_cast.hpp>
int main(int argc, char** argv) {
std::string foo = boost::lexical_cast<std::string>(argc);
}

Answer 19

int number = 123;
stringstream = s;
s << number;
cout << ss.str() << endl;