Il modo più semplice per convertire int in stringa in C ++

Qual è il modo più semplice per convertire da intin equivalente stringin C ++. Sono a conoscenza di due metodi. C'è un modo più semplice?

(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 introduce std::stoi(e varianti per ciascun tipo numerico) e std::to_string, le controparti della C atoie itoama espresse in termini di std::string.

#include <string> 

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

è quindi il modo più breve che mi viene in mente. Puoi anche omettere di nominare il tipo, usando la autoparola chiave:

auto s = std::to_string(42);

Nota: vedere [string.conversions] ( 21.5 in n3242 )

Raccogliendo una discussione con @ v.oddou un paio di anni dopo, C ++ 17 ha finalmente fornito un modo per fare la soluzione di tipo agnostico originariamente basata su macro (conservata sotto) senza passare attraverso la bruttezza delle 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 ) );

Risposta originale:

Poiché "convertire ... in stringa" è un problema ricorrente, definisco sempre la macro SSTR () in un'intestazione centrale delle mie fonti C ++:

#include <sstream>

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

L'utilizzo è semplice come potrebbe essere:

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

Quanto sopra è compatibile con C ++ 98 (se non è possibile utilizzare C ++ 11 std::to_string) e non necessita di inclusioni di terze parti (se non è possibile utilizzare Boost lexical_cast<>); entrambe queste altre soluzioni offrono prestazioni migliori.

Di solito uso il seguente metodo:

#include <sstream>

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

È descritto in dettaglio qui .

Probabilmente il modo più comune per incorporare essenzialmente la tua seconda scelta in un modello chiamato lexical_cast, come quello in Boost , quindi il tuo codice è simile al seguente:

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

Un aspetto interessante è che supporta anche altri cast (ad esempio, nella direzione opposta funziona altrettanto bene).

Si noti inoltre che sebbene Boost lexical_cast sia iniziato come una semplice scrittura su un flusso di stringhe, per poi estrarre nuovamente dallo stream, ora ha un paio di aggiunte. Prima di tutto, sono state aggiunte specializzazioni per parecchi tipi, quindi per molti tipi comuni è sostanzialmente più veloce dell'uso di una stringa. In secondo luogo, ora controlla il risultato, quindi (ad esempio) se si converte da una stringa in una int, può generare un'eccezione se la stringa contiene qualcosa che non può essere convertito in una int(ad esempio, 1234avrebbe esito positivo, ma 123abcverrebbe lanciata) .

A partire da C ++ 11, c'è una std::to_stringfunzione sovraccaricata per i tipi interi, quindi puoi usare codice come:

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

Lo standard definisce questi come equivalenti a fare la conversione con sprintf(usando l'identificatore di conversione che corrisponde al tipo di oggetto fornito, come %dper int), in un buffer di dimensioni sufficienti, quindi creando un std::stringcontenuto di quel buffer.

Se hai installato Boost (che dovresti):

#include <boost/lexical_cast.hpp>

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

Sarebbe più semplice usare i flussi di stringhe:

#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

O fai una funzione:

#include <sstream>

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

Non che io sappia, in puro C ++. Ma una piccola modifica di ciò che hai menzionato

string s = string(itoa(a));

dovrebbe funzionare, ed è piuttosto breve.

È possibile utilizzare std::to_stringdisponibile in C ++ 11 come suggerito da Matthieu M .:

std::to_string(42);

Oppure, se le prestazioni sono fondamentali (ad esempio, se si effettuano molte conversioni), è possibile utilizzare fmt::format_intdalla libreria {fmt} per convertire un numero intero in std::string:

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

O una stringa C:

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

Quest'ultimo non esegue alcuna allocazione dinamica della memoria ed è oltre 10 volte più veloce rispetto std::to_stringai benchmark Boost Karma. Vedere Conversione da numero intero veloce a stringa in C ++ per maggiori dettagli.

Si noti che entrambi sono thread-safe.

Diversamente std::to_string, fmt::format_intnon richiede C ++ 11 e funziona con qualsiasi compilatore C ++.

Disclaimer: sono l'autore della libreria {fmt}.

sprintf()è abbastanza buono per la conversione del formato. È quindi possibile assegnare la stringa C risultante alla stringa C ++ come in 1.

In primo luogo includere:

#include <string>
#include <sstream>

In secondo luogo aggiungere il metodo:

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

Usa il metodo in questo modo:

NumberToString(69);

o

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

L'uso di stringstream per la conversione dei numeri è pericoloso!

Vedi http://www.cplusplus.com/reference/ostream/ostream/operator%3C%3C/ dove dice che operator<<inserisce output formattato.

A seconda delle impostazioni internazionali correnti, un numero intero superiore a 3 cifre può essere convertito in una stringa di 4 cifre, aggiungendo un separatore di migliaia aggiuntivo.

Ad esempio, int = 1000potrebbe essere convertito in una stringa 1.001. Ciò potrebbe impedire le operazioni di confronto.

Quindi consiglio vivamente di usare il std::to_stringmodo. È più facile e fa quello che ti aspetti.

Aggiornato (vedi commenti sotto) :

C ++ 17 fornisce std::to_charsun'alternativa indipendente dalle impostazioni locali a prestazioni più elevate

Per C ++ 98 , ci sono alcune opzioni:

boost/lexical_cast

Boost non fa parte della libreria C ++, ma contiene molte utili estensioni di libreria.

Il lexical_castmodello di funzione offre una forma comoda e coerente per supportare conversioni comuni da e verso tipi arbitrari quando sono rappresentati come testo.
- Documentazione di 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;
}

Per quanto riguarda il runtime, l' lexical_castoperazione richiede circa 80 microsecondi (sulla mia macchina) sulla prima conversione, quindi accelera notevolmente dopo se eseguita in modo ridondante.

itoa

Questa funzione non è definita in ANSI-C e non fa parte di C ++, ma è supportata da alcuni compilatori.
- cplusplus.com

Ciò significa che gcc/ g++non è possibile compilare il codice utilizzando 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;
}

Nessun runtime da segnalare. Non ho installato Visual Studio, che secondo quanto riferito è in grado di compilare itoa.

sprintf

sprintf è una funzione di libreria standard C che funziona su stringhe C ed è un'alternativa perfettamente valida.

Composta una stringa con lo stesso testo che verrebbe stampato se il formato fosse usato su printf, ma invece di essere stampato, il contenuto viene memorizzato come stringa C nel buffer puntato da 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;
}

L' stdio.hintestazione potrebbe non essere necessaria. Per quanto riguarda il runtime, l' sprintfoperazione richiede circa 40 microsecondi (sulla mia macchina) sulla prima conversione, quindi accelera notevolmente dopo se eseguita in modo ridondante.

stringstream

Questo è il modo principale della libreria C ++ di convertire numeri interi in stringhe e viceversa. Esistono funzioni sorelle simili a quelle stringstreamche limitano ulteriormente l'uso previsto del flusso, come ad esempio ostringstream. L'uso ostringstreamspecifico indica al lettore del codice che si intende utilizzare l' <<operatore, in sostanza. Questa funzione è tutto ciò che è particolarmente necessario per convertire un numero intero in una stringa. Vedi questa domanda per una discussione più elaborata.

#include <sstream>
#include <string>

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

Per quanto riguarda il runtime, l' ostringstreamoperazione richiede circa 71 microsecondi (sulla mia macchina), quindi accelera considerevolmente in seguito se eseguita in modo ridondante, ma non tanto quanto le funzioni precedenti .

Ovviamente ci sono altre opzioni e puoi persino includerne una nella tua funzione, ma ciò offre uno sguardo analitico ad alcune di quelle popolari.

C ++ 17 fornisce std :: to_chars come alternativa indipendente dalla locale a prestazioni più elevate.

È piuttosto facile aggiungere dello zucchero sintattico che consente di comporre le stringhe al volo in un modo simile a un flusso

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

Ora puoi aggiungere ciò che vuoi (a condizione che << (std::ostream& ..)sia definito un operatore ) strmake()e usarlo al posto di un std::string.

Esempio:

#include <iostream>

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

MODIFICATO. Se hai bisogno di una conversione veloce di un numero intero con un numero fisso di cifre in char * con riempimento a sinistra con '0' , questo è l'esempio per le architetture little-endian (tutte x86, x86_64 e altre):

Se stai convertendo un numero a due cifre:

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

Se stai convertendo un numero di tre cifre:

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

Se stai convertendo un numero di quattro cifre:

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

E così via fino a numeri di sette cifre. In questo esempio nè un dato intero. Dopo la conversione è possibile accedere alla rappresentazione della stringa come (char*)&s:

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

NOTA: se ne hai bisogno in ordine di byte big-endian, anche se non l'ho testato, ma ecco un esempio: per un numero a tre cifre è int32_t s = 0x00303030 | (n/100)<< 24 | (n/10%10)<<16 | (n%10)<<8;per numeri a quattro cifre (arco a 64 bit): int64_t s = 0x0000000030303030 | (n/1000)<<56 | (n/100%10)<<48 | (n/10%10)<<40 | (n%10)<<32;penso che dovrebbe funzionare.

Uso:

#define convertToString(x) #x

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

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

Funziona con i miei compilatori g ++ per Windows e Linux.

Ecco un altro modo semplice per farlo

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

sprintf è noto per inserire qualsiasi dato in una stringa del formato richiesto.

È possibile convertire un char *array in una stringa come mostrato nella terza riga.

Questo ha funzionato per me -

Il mio codice:

#include <iostream>
using namespace std;

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

C ++ 11 introdotto std::to_string()per tipi numerici:

int n = 123; // Input, signed/unsigned short/int/long/long long/float/double
std::string str = std::to_string(n); // Output, std::string

Uso:

#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 si utilizza MFC , è possibile utilizzare 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));
    }
}

Ora puoi usare to_string(5).

Penso che usare stringstreamsia abbastanza semplice:

 string toString(int n)
 {
     stringstream ss(n);
     ss << n;
     return ss.str();
 }

 int main()
 {
    int n;
    cin >> n;
    cout << toString(n) << endl;
    return 0;
 }

Si utilizza un tipo di contatore di algoritmo per convertire in una stringa. Ho ottenuto questa tecnica dalla programmazione di computer Commodore 64 . È anche buono per la programmazione del gioco.

• Prendi il numero intero e prendi ogni cifra che è ponderata per potenze di 10. Quindi supponi che il numero intero sia 950.

  • Se il numero intero è uguale o maggiore di 100.000, sottrarre 100.000 e aumentare il contatore nella stringa a ["000000"];
    continua a farlo fino a quando non ci saranno più numeri in posizione 100.000. Rilascia un altro potere di dieci.

  • Se il numero intero è uguale o maggiore di 10.000, sottrarre 10.000 e aumentare il contatore nella stringa in ["000000"] + 1 posizione;
    continua a farlo fino a quando non ci saranno più numeri in posizione 10.000.

• Rilascia un altro potere di dieci

• Ripeti lo schema

So che 950 è troppo piccolo per essere usato come esempio, ma spero che tu abbia l'idea.