Alternativa para itoa () para converter inteiro para string C ++?

Eu queria saber se havia uma alternativa para itoa() para converter um inteiro em uma string porque quando eu corro-lo no visual Studio recebo avisos, e quando tento construir meu programa no Linux, recebo um erro de compilation.

Em C ++ 11 você pode usar std::to_string :

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

Se você está trabalhando com o C ++ 11, você pode usar streams de C ++:

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

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

boost :: lexical_cast funciona muito bem.

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

Arqueologia

itoa era uma function auxiliar não padrão projetada para complementar a function padrão atoi e, provavelmente, ocultar um sprintf (a maioria de seus resources podem ser implementados em termos de sprintf): http://www.cplusplus.com/reference/clibrary/cstdlib/ itoa.html

O Caminho C

Use sprintf. Ou snprintf. Ou qualquer ferramenta que você encontrar.

Apesar do fato de algumas funções não estarem no padrão, como corretamente mencionado por “onebyone” em um de seus comentários, a maioria dos compiladores oferecerá uma alternativa (por exemplo, o Visual C ++ tem seu próprio _snprintf que você pode digitar para snprintf se precisar).

O caminho C ++.

Use os streams de C ++ (no caso atual std :: stringstream (ou até mesmo o obsoleto std :: strstream, como proposto por Herb Sutter em um de seus livros, porque é um pouco mais rápido).

Conclusão

Você está em C ++, o que significa que você pode escolher da maneira que você quiser:

  • O caminho mais rápido (ou seja, o caminho C), mas você deve ter certeza de que o código é um gargalo no seu aplicativo (otimizações prematuras são ruins, etc.) e que seu código é encapsulado com segurança para evitar o excesso de buffer.

  • A maneira mais segura (isto é, a maneira C ++), se você conhece essa parte do código não é crítico, então é melhor ter certeza que essa parte do código não irá quebrar em momentos randoms porque alguém confundiu um tamanho ou um ponteiro (o que acontece na vida real, como … ontem, no meu computador, porque alguém achou “legal” usar o modo mais rápido sem precisar dele.

Tente sprintf ():

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

sprintf () é como printf (), mas é enviado para uma string.

Além disso, como Parappa mencionou nos comentários, você pode querer usar snprintf () para impedir que ocorra um estouro de buffer (onde o número que você está convertendo não se encheckbox no tamanho de sua string). Funciona assim:

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

Nos bastidores, o lexical_cast faz isso:

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

Se você não quer “arrastar” impulso para isso, então usar o acima é uma boa solução.

Podemos definir nossa própria function iota em 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; } 

Não esqueça de #include .

С ++ 11 finalmente resolve isso fornecendo std::to_string . Também boost::lexical_cast é uma ferramenta útil para compiladores antigos.

Aqui está uma versão C do itoa, com algumas condições:

 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; } 
  • Isso não lida com números negativos
  • Atualmente, isso não manipula números maiores que 23 caracteres no formato decimal.
  • não é thread-safe
  • o valor de retorno será apagado / corrompido assim que a function for chamada novamente.
    Então, se você quiser manter o valor de retorno, você precisa colocá-lo em um buffer separado.

Eu uso esses modelos

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

Tente Boost.Format ou FastFormat , ambas bibliotecas C ++ de alta qualidade:

 int i = 10; std::string result; 

Com o Boost.Format

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

ou FastFormat

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

Obviamente, ambos fazem muito mais do que uma simples conversão de um único inteiro

Você pode realmente converter qualquer coisa em uma string com uma function de modelo inteligentemente escrita. Este exemplo de código usa um loop para criar subdiretórios em um sistema Win-32. O operador de concatenação de cadeia, operator +, é usado para concatenar uma raiz com um sufixo para gerar nomes de diretórios. O sufixo é criado convertendo a variável de controle de loop, i, em uma string C ++, usando a function template e concatenando-a com outra string.

 //Mark Renslow, Globe University, Minnesota School of Business, Utah Career College //C++ instructor and Network Dean of Information Technology #include  #include  #include  #include  // string stream #include  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  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; } 

Aloque uma string de tamanho suficiente e use snprintf.

A melhor resposta, IMO, é a function fornecida aqui:

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

Ele imita a function não-ANSI fornecida por muitas bibliotecas.

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

Também é muito rápido e otimiza bem abaixo de -O3, e a razão pela qual você não está usando c ++ string_format () … ou sprintf é que eles são muito lentos, certo?

Observe que todos os methods stringstream podem envolver o bloqueio em torno do uso do object local para formatação. Isso pode ser algo a ser cauteloso se você estiver usando essa conversão de vários segmentos …

Veja aqui para mais. Converter um número em uma string com comprimento especificado em C ++

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

Se você estiver interessado em um método de conversão de string rápida e segura para string, e não limitado à biblioteca padrão, recomendo o método FormatInt da biblioteca C ++ Format :

 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 acordo com o inteiro, para comparar os benchmarks de conversão do Boost Karma, esse método é várias vezes mais rápido que o sprintf ou std::stringstream . É ainda mais rápido do que o próprio int_generator do Boost Karma, como foi confirmado por um benchmark independente .

Isenção de responsabilidade: Sou o autor desta biblioteca.

Eu escrevi essa function thread-safe há algum tempo, e estou muito feliz com os resultados e sinto que o algoritmo é leve e enxuto, com desempenho que é cerca de 3 vezes a function _itoa () padrão do MSVC.

Aqui está o link. Ótima Base-10 apenas function itoa ()? O desempenho é pelo menos 10X do sprintf (). O benchmark é também o teste de QA da function, como segue.

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

Há algumas sugestões tolas feitas sobre o uso do armazenamento do responsável pela chamada que deixariam o resultado flutuando em algum lugar em um buffer no espaço de endereço do chamador. Ignore-os. O código que listei funciona perfeitamente, como o código de referência / controle de qualidade demonstra.

Eu acredito que este código é enxuto o suficiente para usar em um ambiente incorporado. YMMV, claro.

Em plataformas derivadas do Windows CE, não há iostream s por padrão. O caminho a seguir é preferível com a família _itoa<> , geralmente _itow<> (já que a maioria das coisas de string são Unicode).

A maioria das sugestões acima tecnicamente não são C ++, são soluções C.

Olhe para o uso de std :: stringstream .