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

1574

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();
Nemo
fonte
4
Eu acho que os dois métodos que você deu são boas soluções. isso depende do contexto em que você precisa fazer isso. Se você já está trabalhando com fluxos, por exemplo, lendo ou gravando um arquivo, seu segundo método é o melhor. Se você precisa passar um int como uma string para um argumento de função, então pode ser uma maneira fácil. Porém, na maioria das vezes, a conversão de sequência de caracteres ocorre ao lidar com arquivos, portanto, os fluxos são apropriados.
Charles Brunet
41
Como a opção 1 funciona mesmo para você? É meu entendimento que itoa()leva três parâmetros.
precisa saber é o seguinte
1
itoa será mais rápido que o equivalente ao fluxo. Também existem maneiras de reutilizar o buffer de strings com o método itoa (evitando alocações de heap se você estiver gerando strings com frequência, por exemplo, para alguns resultados numéricos de atualização rápida). Como alternativa, você pode gerar um streambuf personalizado para reduzir parte da sobrecarga de alocação, etc. Construir o fluxo em primeiro lugar também não é um empreendimento de baixo custo.
Pete
6
@Pete: Uma vez que você começar a se preocupar com o que é mais rápido, você vai querer olhar para stackoverflow.com/questions/4351371/...
Ben Voigt
20
Observe que itoa () não faz parte do padrão e, portanto, usá-lo torna seu código não portátil, pois nem todos os compiladores o suportam. Para o Linux, você certamente está fora, a menos que esteja usando algo diferente do GCC, que não suporta esta função. Se você possui C ++ 0x, siga o que @Matthieu sugeriu em sua resposta. Se não for esse o caso, siga o stringstream, pois é um recurso bem suportado e seu código deve ser compatível com todos os compiladores C ++ existentes. Como alternativa, você sempre pode usar o sprintf ().
rbaleksandar

Respostas:

2102

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 )

Matthieu M.
fonte
199
to_stringnão é membro de stdcorreção: stackoverflow.com/questions/12975341/...
Ben
36
Ou, dependendo do seu compilador, basta definir o padrão de idioma correto:g++ -std=c++11 someFile.cc
Thomas M. DuBuisson
12
@ Steve: deveria ser. É membro de stdtodos os compiladores que conheço, exceto um.
Mooing Duck
5
@Matthiew M. Estou usando o mesmo que você sugere, mas eu estou recebendo este erro: Error : No instance of overloaded function "std::to_string" matches the argument list eu estou usando VS2010 c ++
19
@Vôo: no VS2010, você deve converter explicitamente o número inteiro convertido em um dos seguintes tipos [_Longlong, _ULonglong, long double]; ou seja:string s = to_string((_ULonglong)i);
Zac
184

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.

DevSolar
fonte
2
Eu não estou muito familiarizado, dynamic_castmas estou usando o clang para compilar, de modo que se queixe. Se eu simplesmente omitir o dynamic_cast, ele compila bem; que finalidade dynamic_castserve nesse caso? Já estamos criando um ostringstream, então por que lançá-lo?
Mathew
2
@ Matthew: O link na minha resposta leva a uma descrição detalhada de cada parte da construção. Enquanto criamos um ostringstream, nós o chamamos operator<<(), que retorna ostream &- para o qual .str()não está definido. Eu realmente me pergunto como o clang faria esse trabalho sem o elenco (ou por que ele gera um erro). Esse construto é publicado em muitos lugares e eu o uso há mais de uma década em muitos compiladores diferentes, incluindo MSVC, GCC e XLC, por isso estou surpreso com o fato de ele não gostar.
DevSolar 21/10
5
Só vim à festa por curiosidade, e voto a favor. Razão: muitos votos para uma solução pouco elegante e provavelmente lenta. 1. uso de macro. Eu não sistematicamente desaprovo nenhuma macro, mas essa é muito curta e os clientes finais sempre temem a repetição do argumento, além do medo de macros de multilinhas desprotegidas. (não protegido por do {} while (0)) 2. dynamic_cast. parece que você só precisa de um static_cast aqui, a menos que queira afirmar que a biblioteca realmente foi implementada como você espera. nesse caso, você deve usar boost :: polymorphic_downcast.
v.oddou
2
@ v.oddou: Você é livre para criticar, é claro. Mas 1. é inválido - a macro é uma única instrução, do { } while( 0 )não adicionaria nada. Com 2. e 3. você provavelmente entendeu - isso pode ser feito com um elenco estático, e talvez um de vocês assistentes de modelos possa criar uma interface "melhor". Mas como eu disse, isso não é de forma alguma uma invenção minha. Olhe ao seu redor, essa macro (macro!) É bastante onipresente. Esse é um caso de POLA em si. Eu posso brincar um pouco com isso para torná-lo mais "simplificado".
DevSolar
1
@ v.oddou: Veja o que eu achei entre as coisas que o C ++ 17 nos trouxe. :-) Espero que você goste da resposta atualizada.
DevSolar
109

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 .

Rasoul
fonte
2
Antes de usar ss, você precisa ss.clear(). Eu vi resultados inesperados sem essa inicialização.
lifebalance
14
@lifebalance: Eu nunca vi esse comportamento.
Rasoul
18
@ equilíbrio da vida: Você não precisa de clear()um ostringstreamobjeto recém-criado . clear()redefine os sinalizadores de erro / EO e ainda não foi gerada nenhuma condição de erro / EO.
Remy Lebeau
2
@Rasoul NumberToString(23213.123)produz 23213.1enquanto std::to_string(23213.123)produz 23213.123000O que acontece lá?
Killzone Kid
1
@KillzoneKid Isso ocorre porque std 'ostream é stateful (isso significa que qualquer alteração de estado anterior é mantida, como o número de dígitos decimais), enquanto esse método começa com um estado padrão.
xryl669
85

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.

Jerry Coffin
fonte
2
Bom, prefiro a resposta de Kevin, embora ele mostre o espaço para nome e inclusão. Apenas uma queixa menor. :) Bom trabalho!
Jason R. Mick
4
Eu diria que este é o caminho a percorrer se você não tiver suporte ao C ++ 11.
21413 Alex
40

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);
Kevin
fonte
4
Acordou na instalação do impulso. Eu acho que mais do que muitas vezes formataríamos a string. Para este efeito, eu prefiro boost :: formato por exemplo formato ( "% 02d", número) .str ()
Werner Erasmus
28

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();
}
user2287915
fonte
18

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.

user541686
fonte
55
itoa()não é uma função padrão!
cartunista
4
@ cartoonist: Então o que é isso?
user541686
20
Esta função não está definida no ANSI-C e C ++. Portanto, não é suportado por algum compilador, como o g ++.
cartunista
17

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

vitaut
fonte
2
Eu estava curioso sobre a alegação de não ter nenhuma alocação dinâmica de memória enquanto permanecer seguro de thread (reentrante), então li o seu código - c_str()retorna um ponteiro para um buffer declarado dentro da fmt::FormatIntclasse - para que o ponteiro retornado seja inválido em o ponto e vírgula - ver também stackoverflow.com/questions/4214153/lifetime-of-temporaries
Soren
1
Sim, o mesmo comportamento que com std::string::c_str()(portanto, a nomeação). Se você quiser usá-lo fora da expressão completa, construa um objeto. FormatInt f(42);Você poderá usá-lo f.c_str()sem o risco de ser destruído.
Vitaut
1
Eu recebo algo estranho quando tento converter de int para string usando std :: to_string (num). Se eu armazenar o resultado em uma variável e tentar acessá-lo como stringNum [1] ou stringNum [n] à medida que n aumenta, recebo lixo.
user8951490
1
Essa é definitivamente a resposta certa para essa pergunta: código eficiente e padrão que não é stateful.
precisa saber é o seguinte
16

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

Throwback1986
fonte
1
Heh sim. No entanto, eu costumo confiar em snprintf () e amigos para qualquer coisa importante ao lidar com seqüências C.
usar o seguinte
1
@MatthieuM. Seu comentário prova ainda mais que você não é. Se a saída foi truncada devido a esse limite, o valor de retorno é o número de caracteres (excluindo o byte nulo final) que teriam sido gravados na sequência final se houvesse espaço suficiente disponível. Assim, um valor de retorno de tamanho ou mais significa que a saída foi truncada. Você pode chamá-lo com NULLtamanho zero e para obter o tamanho necessário do buffer.
User1095108
2
@ user1095108: Acho que você está enganado snprintf(observe o prefixo SNP ) e sprintf(observe o prefixo SP ). Você passa o tamanho para o anterior e toma cuidado para não exceder o limite, no entanto, o último desconhece o tamanho do buffer e, portanto, pode exceder.
Matthieu M.
1
A idéia é chamar uma snprintfvariante primeiro e uma sprintfvariante depois disso. Como o tamanho do buffer é conhecido até então, a chamada sprintfse torna totalmente segura.
user1095108
1
@ user1095108 Ah, sim. Se o primeiro buffer para snprintf for insuficiente, o valor de retorno informa o que seria suficiente. Eu ainda usaria o snprintf para a segunda chamada, porque confiar nas implementações do sprintf e snprintf para corresponder é desnecessariamente perigoso.
mabraham
11

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!."
Alex
fonte
10

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

YesThatIsMyName
fonte
2
Concordo que este é um problema sério se você precisar trocar dados. Infelizmente, também std::to_stringusa a localidade atual (consulte en.cppreference.com/w/cpp/string/basic_string/to_string , a seção 'Notas'). Quase todas as ferramentas padrão (de strings para sprintf, mas também sscanfetc) estão usando a localidade atual. Eu não estava ciente disso até recentemente, quando me bateu forte. Atualmente usando coisas caseiras, não é difícil de fazer.
Bert Bril 24/10
No link acima, também é declarado que o C ++ 17 fornece std :: to_chars como uma alternativa independente de localidade de alto desempenho.
YesThatIsMyName
Infelizmente, eu estou preso ao C ++ 11 nos próximos anos (uma grande melhoria já, felizmente).
Bert Bril
1
from_chars e to_chars seria perfeito, mas infelizmente eles não oferecem uma variante wchar_t.
gast128
8

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.

Joshua Detwiler
fonte
Obrigado por cuidar de nós (usuários do C ++ 98)
A. B
@ AB Não posso acreditar que ainda existem usuários de C ++ 98.
Kotauskas 03/07/19
@VladislavToncharov Quando seu trabalho é exclusivamente para oferecer suporte a equipamentos e códigos herdados, você mexe nas coisas antigas usando os padrões mais recentes do setor. Há um verão, eu estava escrevendo código no Python 2.3.
Joshua Detwiler
@ JoshuaDetwiler Oh, esqueci disso, desculpe.
Kotauskas
4

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


fonte
3

É 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;
}
AndreyS Scherbakov
fonte
2

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.

Alek
fonte
2
E quanto à ordem de bytes?
shjeff 10/01/19
Esse comportamento indefinido não é devido ao alias do ponteiro?
dgnuff
1
@shjeff obrigado pelo comentário, adicionei uma nota sobre endianness à resposta.
Alek
@gngnuff obrigado por apontar isso, embora eu não tenha tido problemas com isso, você está certo. Modifiquei ligeiramente a resposta para que ela cumpra as Regras de aliasing estritas, obrigado.
Alek
1

Usar:

#define convertToString(x) #x

int main()
{
    convertToString(42); // Returns const char* equivalent of 42
}
maverick9888
fonte
3
Funciona apenas com números literais, não avalia o conteúdo variável, embora seja útil algumas vezes.
Lobo
Direita. Mas definitivamente útil no momento
maverick9888
1
Só funciona em tempo de compilação com números constantes literais, acho que o OP pede uma conversão dinâmica, usando números inteiros variáveis
Ing. Gerardo Sánchez
0

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 ++.

J_C
fonte
0

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.

Natesh bhat
fonte
0

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;
}
Gonçalo Garrido
fonte
Essencialmente usando o que? stringstream?
Peter Mortensen
@PeterMortensen olhar com cuidado, éstd::to_string()
Kotauskas
tenho using namespace std;:)
Gonçalo Garrido
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
Kamrujjaman Joy
fonte
4
Oi! Você poderia adicionar uma explicação sobre por que e como isso fornece uma resposta para a pergunta?
Outro # nó 26/07
0

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;
}
Tayyab Mazhar
fonte
1
Falha completamente para n≤0
Toby Speight
-1
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;
}
Abdullah Abdelmonem
fonte
1
Obrigado por este trecho de código, que pode fornecer ajuda limitada a curto prazo. Uma explicação adequada melhoraria bastante seu valor a longo prazo, mostrando por que essa é uma boa solução para o problema e a tornaria mais útil para futuros leitores com outras perguntas semelhantes. Por favor edite sua resposta para adicionar alguma explicação, incluindo as suposições que você fez.
Toby Speight
Falha completamente para n≤0
Toby Speight
Adicione comentários, explique sua resposta, leia como responder .
Aksen P
-1

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

int a = 10;
CString strA;
strA.Format("%d", a);
Tur1ng
fonte
8
Você deve observar que esta é uma extensão somente da Microsoft: msdn.microsoft.com/en-us/library/ms174288.aspx
JonnyJD
1
Eu amo a idéia de CString :: Format (). Infelizmente, não é MS portátil apenas.
24416 Nick
1
Eu atualizei minha resposta para incluir as informações do seu comentário @ JonnyJD, pois continuo com o
voto negativo
-2
char * bufSecs = new char[32];
char * bufMs = new char[32];
sprintf(bufSecs, "%d", timeStart.elapsed()/1000);
sprintf(bufMs, "%d", timeStart.elapsed()%1000);
user2047065
fonte
12
vazamentos de memória, -1 de mim
paulm 25/03
Isso cheira a saturação de buffer.
Kotauskas 03/07/19
-2
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).

Peter Mortensen
fonte
10
Enquanto esta solução funciona, é altamente desencorajada! Nomes começando com sublinhado e uma letra maiúscula são reservados para o compilador, você nunca deve usá-los. Injetar funções no stdespaço para nome também não é algo que você deve fazer. Além disso, não parece _MAX_INT_DIGser uma macro padrão; portanto, se for definido incorretamente, esse código terá o grande potencial de induzir um comportamento indefinido. -1
iFreilicht
6
O que é _MAX_INT_DIG e por que é duplicado?
22915 paulm
-2

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;
 }
rashedcs
fonte
Isso foi mencionado na pergunta e, infelizmente, é bastante lento.
Kotauskas 03/07/19
-3

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.

AdmiralSmith
fonte
Não é muito útil descrever um algoritmo, em vez de mostrar um exemplo no código.
cdeerinck