Alternativa para itoa () para converter inteiro para string C ++? [duplicado]

Question

Esta questão já tem uma resposta aqui:

• maneira mais fácil de converter int para string em C ++ 28 respostas

Eu queria saber se havia uma alternativa para itoa() para converter um inteiro para uma cadeia porque quando eu executá-lo no Visual Studio Recebo avisos, e quando eu tentar construir o meu programa no Linux, eu recebo um erro de compilação.

Answer 1

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

#include <string>

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

Se você está trabalhando com antes do C ++ 11, você pode usar C ++ córregos:

#include <sstream>

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

http: //notfaq.wordpress .com / 2006/08/30 / c-converter-int-to-string /

Answer 2

boost :: lexical_cast funciona muito bem.

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

Answer 3

Arqueologia

itoa era uma função auxiliar não padrão concebido para complementar o padrão função atoi, e provavelmente escondendo um sprintf (A maioria das suas características podem ser implementadas em termos de sprintf): http://www.cplusplus.com/reference/clibrary/cstdlib/itoa.html

A C Way

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

Apesar do fato de algumas funções não estão no padrão, como bem mencionado por "onebyone" em um de seus comentários, a maioria compilador irá oferecer-lhe uma alternativa (por exemplo, Visual C ++ tem a sua própria _snprintf você pode typedef para snprintf se precisar -lo).

caminho O C ++.

Use os fluxos de C ++ (no caso atual std :: stringstream (ou mesmo o preterido 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 a maneira que você quer:

• A maneira mais rápida (ou seja, a forma C), mas você deve ter certeza que o código é um gargalo no seu aplicativo (otimizações prematuras são maus, etc.) e que o seu código é encapsulado com segurança para evitar o risco de estouros de buffer .

• A maneira mais segura (ou seja, o C ++ caminho), se você sabe esta parte do código não é crítico, então é melhor ter certeza que esta parte do código não vai quebrar em momentos aleatórios porque alguém confundiu um tamanho ou um ponteiro (o que acontece na vida real, como ... ontem, no meu computador, porque alguém pensou que "cool" para usar o caminho mais rápido sem realmente precisar dele).

Answer 4

Tente sprintf ():

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

sprintf () é como printf (), mas saídas para uma string.

Além disso, como Parappa mencionado nos comentários, você pode querer usar snprintf () para parar um estouro de buffer de ocorrência (onde o número que você está convertendo não se encaixa o tamanho de sua corda.) Funciona assim :

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

Answer 5

Nos bastidores, lexical_cast faz isso:

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

Se você não quer "arrastar no" impulso para este, em seguida, usando o acima é uma boa solução.

Answer 6

Podemos definir a nossa própria função 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 se esqueça de #include <string>.

Answer 7

? ++ 11 finalmente resolve este fornecendo std::to_string . Também boost::lexical_cast é ferramenta útil para compiladores mais antigos.

Answer 8

Eu uso esses modelos

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 9

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

int i = 10;
std::string result;

Com 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 número inteiro

Answer 10

Você pode realmente converter qualquer coisa para uma string com uma função de modelo inteligentemente escrito. Este exemplo de código usa um loop para criar subdiretórios em um sistema de Win-32. O operador de concatenação, o operador +, é usado para concatenar uma raiz com um sufixo para gerar nomes de diretório. O sufixo é criado através da conversão da variável de controlo de circuito, i, para uma cadeia de C ++, utilizando a função de modelo, e concatenar com que uma outra cadeia.

//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 11

Alocar uma cadeia de comprimento suficiente, então use snprintf.

Answer 12

A melhor resposta, IMO, é a função fornecida aqui:

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

Ele imita a função não-ANSI fornecidas por muitas libs.

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

É também muito rápido e otimiza bem sob O3, ea razão pela qual você não está usando c ++ string_format () ... ou sprintf é que eles são muito lento, certo?

Answer 13

Note-se que todos os métodos stringstream <> fortes podem envolvem travamento em torno do uso do objecto da localidade para a formatação. Este pode ser algo a ser cauteloso se você estiver usando esta conversão de vários segmentos ...

Veja aqui para mais. Convert um número de cadeia de caracteres com um comprimento especificado em C ++

Answer 14

int number = 123;

stringstream = s;

s << number;

cout << ss.str() << endl;

Answer 15

Se você está interessado em rápido, bem como inteiro seguro método de conversão de cadeia e não se limitando a biblioteca padrão, eu posso recomendar o método FormatInt do Format C ++ biblioteca:

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 a inteiro para benchmarks de conversão de cadeia de impulso Karma, este método várias vezes mais rápido do que sprintf ou std::stringstream da glibc. É ainda mais rápido do que o impulso próprio int_generator do Karma como era confirmar por uma independente referência .

Disclaimer: Eu sou o autor desta biblioteca

.

Answer 16

Eu escrevi este função thread-safe há algum tempo, e estou muito feliz com os resultados e sentir o algoritmo é leve e magra, com um desempenho que é de cerca de 3X a _itoa MSVC padrão function () .

Aqui está o link. única função itoa () óptima Base-10? Desempenho é pelo menos 10X que de sprintf (). O valor de referência é também teste de QA da função, 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));

Existem algumas sugestões tolas feitas sobre o uso de armazenamento do chamador, que deixaria o resultado flutuando em algum lugar em um buffer no espaço de endereço do chamador. Ignore-os. O código que eu listados funciona perfeitamente, como o código de referência / QA demonstra.

Eu acredito que este código é bastante magra para usar em um ambiente incorporado. YMMV, é claro.

Answer 17

Em Windows CE derivado plataformas, não há iostreams por padrão. O caminho a percorrer há preferaby com a família _itoa<>, geralmente _itow<> (desde a maioria das coisas corda são Unicode lá de qualquer maneira).

Answer 18

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

Olhe para o uso de std :: stringstream .