c++ - stoi - uint32_t to string




Il modo più semplice per convertire int in string in C++ (17)

Qual è il modo più semplice per convertire da int a string equivalente in 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();

Ecco un altro modo semplice per fare

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

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

È possibile convertire l'array char * in stringa come mostrato nella terza riga.


È piuttosto semplice aggiungere dello zucchero sintattico che consente di comporre stringhe al volo in un modo simile al 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 qualunque cosa tu voglia (ammesso che un operatore << (std::ostream& ..) sia definito per esso) a strmake() e usarlo al posto di uno std::string .

Esempio:

#include <iostream>

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

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


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 windows e linux g ++.


Non sarebbe più semplice usare i diagrammi?

#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

Oppure fai una funzione:

#include <sstream>

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

Penso che usare lo stringstream sia piuttosto 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;
 }

Probabilmente il modo più semplice è quello di avvolgere 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);

Una buona parte di questo è 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 uno stringstream, quindi si estrae nuovamente dallo stream, ora ha un paio di aggiunte. Prima di tutto, sono state aggiunte specializzazioni per diversi tipi, quindi per molti tipi comuni, è sostanzialmente più veloce rispetto all'utilizzo di uno stringstream. Secondo, ora controlla il risultato, quindi (per esempio) se si converte da una stringa a una int , si può generare un'eccezione se la stringa contiene qualcosa che non può essere convertito in un int (ad esempio, 1234 avrebbe avuto successo, ma 123abc avrebbe gettato).

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

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

Lo standard definisce questi come equivalenti a fare la conversione con sprintf (usando lo specificatore di conversione che corrisponde al tipo di oggetto fornito, come %d per int ), in un buffer di dimensioni sufficienti, quindi creando una std::string contenuto di quel buffer


Puoi usare std::to_string disponibile in C ++ 11 come suggerito da Matthieu M .:

std::to_string(42);

Oppure, se le prestazioni sono fondamentali (ad esempio, se si eseguono molte conversioni), è possibile utilizzare fmt::FormatInt dalla libreria di formato C ++ per convertire un numero intero in std::string :

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

O una stringa C:

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

Quest'ultimo non fa allocazioni di memoria dinamica ed è più di 10 volte più veloce di std::to_string sui benchmark di Boost Karma. Vedi Fast integer per convertire le stringhe in C ++ per maggiori dettagli.

A differenza di std::to_string , fmt::FormatInt non richiede C ++ 11 e funziona con qualsiasi compilatore C ++.

Disclaimer: sono l'autore della libreria di formato C ++.


Se hai bisogno di convertire velocemente un numero intero con un numero fisso di cifre in char * lasciato con "0", questo è un esempio pratico:

int n = 27;
char s[8];

Se stai convertendo un numero a due cifre:

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

Se stai convertendo un numero a tre cifre:

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

Se si sta convertendo un numero a 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 a sette cifre :)


Se hai installato Boost (che dovresti):

#include <boost/lexical_cast.hpp>

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

Uso:

#define convertToString(x) #x

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

Utilizzando CString :

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

Per C ++ 98 , ci sono alcune opzioni:

boost/lexical_cast

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

Il modello di funzione lexical_cast offre una forma comoda e coerente per supportare le conversioni comuni da e verso tipi arbitrari quando sono rappresentati come testo.
- Boost's Documentation

#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'operazione lexical_cast impiega circa 80 microsecondi (sulla mia macchina) alla prima conversione, quindi accelera considerevolmente in seguito 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 può compilare il codice 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;
}

Nessun runtime da segnalare. Non ho installato Visual Studio, che è reportedly grado di compilare itoa .

sprintf

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

Compone una stringa con lo stesso testo che verrebbe stampata se il formato fosse usato su printf, ma invece di essere stampato, il contenuto è memorizzato come una 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'intestazione stdio.h potrebbe non essere necessaria. Per quanto riguarda il runtime, l'operazione sprintf impiega circa 40 microsecondi (sulla mia macchina) alla prima conversione, per poi accelerare considerevolmente in seguito se eseguita in modo ridondante.

stringstream

Questo è il modo principale della libreria C ++ per convertire gli interi in stringhe e viceversa. Esistono altre funzioni simili a stringstream che limitano ulteriormente l'uso previsto del flusso, come ad esempio ostringstream . L'uso di ostringstream dice espressamente al lettore del tuo codice che intendi solo utilizzare l'operatore << , in sostanza. Questa funzione è tutto ciò che è particolarmente necessario per convertire un 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'operazione ostringstream impiega circa 71 microsecondi (sulla mia macchina), per poi accelerare considerevolmente in seguito se eseguita in modo ridondante, ma non tanto quanto le funzioni precedenti .

Ovviamente ci sono altre opzioni, e puoi persino inserire una di queste nella tua funzione, ma questo offre uno sguardo analitico ad alcuni di quelli popolari.


Usare lo stringstream per la conversione del numero è pericoloso!

Vedere http://www.cplusplus.com/reference/ostream/ostream/operator%3C%3C/ dove indica che l' operator<< inserisce l'output formattato.

A seconda delle impostazioni locali correnti, un numero intero maggiore di 3 cifre potrebbe essere convertito in una stringa di 4 cifre, aggiungendo un separatore extra di migliaia.

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

Quindi consiglio vivamente di usare la modalità std::to_string . È più facile e fa quello che ti aspetti.


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

int n = 123;
std::string str = std::to_string(n);

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




type-conversion