A maneira mais fácil de converter int para string em C ++

Qual é a maneira mais fácil de converter de intequivalente stringem C ++. Estou ciente de dois métodos. Existe alguma maneira mais 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();

C ++ 11 introduz std::stoi(e variantes para cada tipo numérico) e std::to_string, as contrapartes de C atoie itoamas expressas em termos de std::string.

#include <string> 

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

é, portanto, a maneira mais curta em que consigo pensar. Você pode até omitir a nomeação do tipo, usando a autopalavra-chave:

auto s = std::to_string(42);

Nota: consulte [string.conversions] ( 21.5 no n3242 )

Iniciando uma discussão com o @ v.oddou alguns anos depois, o C ++ 17 finalmente ofereceu uma maneira de executar a solução agnóstica do tipo originalmente baseada em macro (preservada abaixo) sem passar pela feia 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 ) );

Resposta original:

Como "converter ... em string" é um problema recorrente, eu sempre defino a macro SSTR () em um cabeçalho central das minhas fontes C ++:

#include <sstream>

#define SSTR( x ) static_cast< std::ostringstream & >( \
        ( std::ostringstream() << std::dec << x ) ).str()

O uso é o mais fácil possível:

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

O acima é compatível com C ++ 98 (se você não pode usar o C ++ 11 std::to_string) e não precisa de inclusões de terceiros (se você não pode usar o Boost lexical_cast<>); essas outras soluções têm um desempenho melhor.

Eu normalmente uso o seguinte método:

#include <sstream>

template <typename T>
  std::string NumberToString ( T Number )
  {
     std::ostringstream ss;
     ss << Number;
     return ss.str();
  }

É descrito em detalhes aqui .

Provavelmente, a maneira fácil mais comum envolve essencialmente sua segunda opção em um modelo nomeado lexical_cast, como o do Boost , para que seu código fique assim:

int a = 10;
string s = lexical_cast<string>(a);

Um detalhe disso é que ele também suporta outros elencos (por exemplo, na direção oposta também funciona).

Observe também que, embora o Boost lexical_cast tenha começado apenas gravando em um string, e sendo extraído novamente do stream, agora ele tem algumas adições. Primeiro, foram adicionadas especializações para alguns tipos; portanto, para muitos tipos comuns, é substancialmente mais rápido que o uso de um fluxo de string. Segundo, agora ele verifica o resultado; portanto (por exemplo), se você converter de uma string para uma int, poderá lançar uma exceção se a string contiver algo que não pode ser convertido em uma int(por exemplo, 1234teria sucesso, mas 123abcseria) .

No C ++ 11, há uma std::to_stringfunção sobrecarregada para tipos inteiros, para que você possa usar código como:

int a = 20;
std::string s = std::to_string(a);
// or: auto s = std::to_string(a);

O padrão define isso como equivalente à conversão com sprintf(usando o especificador de conversão que corresponde ao tipo de objeto fornecido, como %dpara int), em um buffer de tamanho suficiente e, em seguida, criando um std::stringconteúdo desse buffer.

Se você tiver o Boost instalado (o que você deve):

#include <boost/lexical_cast.hpp>

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

Seria mais fácil usar strings:

#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

Ou faça uma função:

#include <sstream>

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

Não que eu saiba, em C ++ puro. Mas uma pequena modificação do que você mencionou

string s = string(itoa(a));

deve funcionar, e é bem curto.

Você pode usar std::to_stringdisponível no C ++ 11, conforme sugerido por Matthieu M .:

std::to_string(42);

Ou, se o desempenho for crítico (por exemplo, se você fizer muitas conversões), poderá usar a fmt::format_intpartir da biblioteca {fmt} para converter um número inteiro em std::string:

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

Ou uma string C:

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

O último não realiza alocações dinâmicas de memória e é 10 vezes mais rápido que std::to_stringnos benchmarks Boost Karma. Consulte Conversão rápida de número inteiro para string em C ++ para obter mais detalhes.

Observe que ambos são seguros para threads.

Ao contrário std::to_string, fmt::format_intnão requer C ++ 11 e funciona com qualquer compilador C ++.

Isenção de responsabilidade: sou o autor da biblioteca {fmt}.

sprintf()é muito bom para conversão de formato. Você pode atribuir a sequência C resultante à sequência C ++, como fez em 1.

Primeiro incluem:

#include <string>
#include <sstream>

Segundo, adicione o método:

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

Use o método como este:

NumberToString(69);

ou

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

Usar string para conversão de números é perigoso!

Consulte http://www.cplusplus.com/reference/ostream/ostream/operator%3C%3C/ onde diz que operator<<insere saída formatada.

Dependendo da localidade atual, um número inteiro maior que 3 dígitos pode ser convertido em uma sequência de 4 dígitos, adicionando um separador de milhares extra.

Por exemplo, int = 1000pode ser convertido em uma string 1.001. Isso poderia fazer com que as operações de comparação não funcionassem.

Então, eu recomendo fortemente usar o std::to_stringcaminho. É mais fácil e faz o que você espera.

Atualizado (veja os comentários abaixo) :

O C ++ 17 fornece std::to_charscomo uma alternativa independente de localidade de alto desempenho

Para o C ++ 98 , existem algumas opções:

boost/lexical_cast

O Boost não faz parte da biblioteca C ++, mas contém muitas extensões úteis da biblioteca.

O lexical_castmodelo de função oferece uma forma conveniente e consistente para oferecer suporte a conversões comuns de e para tipos arbitrários quando elas são representadas como texto.
- Documentação da 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;
}

Quanto ao tempo de execução, a lexical_castoperação leva cerca de 80 microssegundos (na minha máquina) na primeira conversão e, em seguida, acelera consideravelmente depois, se for feita de forma redundante.

itoa

Esta função não está definida no ANSI-C e não faz parte do C ++, mas é suportada por alguns compiladores.
- cplusplus.com

Isso significa que gcc/ g++não é possível compilar o 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;
}

Sem tempo de execução para relatar. Eu não tenho Visual Studio instalado, que é supostamente capaz de compilar itoa.

sprintf

sprintf é uma função de biblioteca padrão C que funciona em cadeias C e é uma alternativa perfeitamente válida.

Compõe uma sequência com o mesmo texto que seria impresso se o formato fosse usado em printf, mas, em vez de ser impresso, o conteúdo é armazenado como uma sequência C no buffer apontado 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;
}

O stdio.hcabeçalho pode não ser necessário. Quanto ao tempo de execução, a sprintfoperação leva cerca de 40 microssegundos (na minha máquina) na primeira conversão e, em seguida, acelera consideravelmente depois, se for feita de forma redundante.

stringstream

Essa é a principal maneira da biblioteca C ++ de converter números inteiros em seqüências de caracteres e vice-versa. Existem funções irmãs semelhantes às stringstreamque limitam ainda mais o uso pretendido do fluxo, como ostringstream. Usar ostringstreamespecificamente informa ao leitor do seu código que você pretende apenas usar o <<operador, essencialmente. Essa função é tudo o que é particularmente necessário para converter um número inteiro em uma string. Veja esta pergunta para uma discussão mais elaborada.

#include <sstream>
#include <string>

int main() {
    int x = 5;
    std::ostringstream stream;
    stream << x;
    std::string x_str = stream.str();
    return 0;
}

Quanto ao tempo de execução, a ostringstreamoperação leva cerca de 71 microssegundos (na minha máquina) e, em seguida, acelera consideravelmente depois se for feita de forma redundante, mas não tanto quanto as funções anteriores .

É claro que existem outras opções, e você pode até incluir uma delas em sua própria função, mas isso oferece uma visão analítica de algumas das populares.

O C ++ 17 fornece std :: to_chars como uma alternativa independente de localidade de alto desempenho.

É bastante fácil adicionar um pouco de açúcar sintático que permita compor cordas em tempo real de maneira semelhante a um fluxo

#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();}
};

Agora você pode anexar o que quiser (desde que um operador << (std::ostream& ..)esteja definido para ele) strmake()e usá-lo no lugar de um std::string.

Exemplo:

#include <iostream>

int main() {
    std::string x =
      strmake() << "Current time is " << 5+5 << ":" << 5*5 << " GST";
    std::cout << x << std::endl;
}

EDITADO. Se você precisar de uma conversão rápida de um número inteiro com um número fixo de dígitos para char * preenchido à esquerda com '0' , este é o exemplo para arquiteturas little-endian (todas x86, x86_64 e outras):

Se você estiver convertendo um número de dois dígitos:

int32_t s = 0x3030 | (n/10) | (n%10) << 8;

Se você estiver convertendo um número de três dígitos:

int32_t s = 0x303030 | (n/100) | (n/10%10) << 8 | (n%10) << 16;

Se você estiver convertendo um número de quatro dígitos:

int64_t s = 0x30303030 | (n/1000) | (n/100%10)<<8 | (n/10%10)<<16 | (n%10)<<24;

E assim por diante, até números de sete dígitos. Neste exemplo né um número inteiro especificado. Após a conversão, a representação da string pode ser acessada como (char*)&s:

std::cout << (char*)&s << std::endl;

NOTA: Se você precisar dele em ordem de bytes big-endian, embora eu não o tenha testado, mas aqui está um exemplo: para números de três dígitos, é int32_t s = 0x00303030 | (n/100)<< 24 | (n/10%10)<<16 | (n%10)<<8;para números de quatro dígitos (arco de 64 bits): int64_t s = 0x0000000030303030 | (n/1000)<<56 | (n/100%10)<<48 | (n/10%10)<<40 | (n%10)<<32;acho que deve funcionar.

Usar:

#define convertToString(x) #x

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

Eu 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 nos meus compiladores Windows e Linux g ++.

Aqui está outra maneira fácil de fazer

char str[100];
sprintf(str, "%d", 101);
string s = str;

sprintf é conhecido por inserir dados em uma sequência do formato necessário.

Você pode converter uma char *matriz em uma string, como mostrado na terceira linha.

Isso funcionou para mim -

Meu código:

#include <iostream>
using namespace std;

int main()
{
    int n = 32;
    string s = to_string(n);
    cout << "string: " + s  << endl;
    return 0;
}

C ++ 11 introduzido 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

Usar:

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

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

Se você estiver usando o MFC , poderá usar CString:

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

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

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

Agora você pode usar to_string(5).

Eu acho que usar stringstreamé bem 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;
 }

Você usa um tipo de contador de algoritmo para converter em uma string. Eu peguei essa técnica de programação de computadores Commodore 64 . Também é bom para programação de jogos.

• Você pega o número inteiro e cada dígito ponderado pelas potências de 10. Portanto, assuma que o número inteiro é 950.

  • Se o número inteiro for igual ou superior a 100.000, subtraia 100.000 e aumente o contador na string em ["000000"];
    continue fazendo isso até que não haja mais números na posição 100.000. Solte outro poder de dez.

  • Se o número inteiro for igual ou superior a 10.000, subtraia 10.000 e aumente o contador na string na posição ["000000"] + 1;
    continue fazendo isso até que não haja mais números na posição 10.000.

• Solte outro poder de dez

• Repita o padrão

Sei que o 950 é muito pequeno para ser usado como exemplo, mas espero que você entenda.