c++ stoi char - Il modo più semplice per convertire int in string in C ++





12 Answers

Raccogliendo una discussione con @ v.oddou un paio di anni dopo, C ++ 17 ha finalmente fornito un modo per fare la soluzione agnostica di tipo originariamente basata su macro (conservata sotto) senza passare attraverso la macabria della macro.

template < typename... Args >
std::string sstr( Args &&... args )
{
    std::ostringstream sstr;
    ( 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 dei miei sorgenti C ++:

#include <sstream>

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

L'utilizzo è facile 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 puoi usare C ++ 11 std::to_string ), e non ha bisogno di std::to_string terze parti (se non puoi usare Boost lexical_cast<> ); entrambe queste altre soluzioni hanno comunque prestazioni migliori.

ot value of

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



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




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



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




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




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.




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



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




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



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



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.




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



Related