Hva er den enkleste måten å konvertere fra int
til tilsvarende string
i C++. Jeg er klar over to metoder. Er det noen enklere måte?
(1)
int a = 10;
char *intStr = itoa(a);
string str = string(intStr);
(2)
int a = 10;
stringstream ss;
ss << a;
string str = ss.str();
Plukke opp en diskusjon med @v.oddou et par år senere, C++17 har endelig levert en måte å gjøre den opprinnelig makro-basert type-agnostic løsning (bevart nedenfor) uten å gå gjennom makro stygghet.
// variadic template
template < typename... Args >
std::string sstr( Args &&... args )
{
std::ostringstream sstr;
// fold expression
( sstr << std::dec << ... << args );
return sstr.str();
}
Bruk:
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 ) );
Original answer:
Siden " konvertering ... til streng " er et tilbakevendende problem, definerer jeg alltid SSTR() makroen i en sentral header i C++-kildene mine:
#include <sstream>
#define SSTR( x ) static_cast< std::ostringstream & >( \
( std::ostringstream() << std::dec << x ) ).str()
Bruken er så enkel som mulig:
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 ) );
Ovennevnte er C++98-kompatibel (hvis du ikke kan bruke C++11 std::to_string
), og trenger ingen tredjeparts inkluderinger (hvis du ikke kan bruke Boost lexical_cast<>
); begge disse andre løsningene har imidlertid bedre ytelse.
Sannsynligvis den vanligste enkle måten pakker i hovedsak ditt andre valg inn i en mal som heter lexical_cast
, slik som den i Boost, slik at koden din ser slik ut:
int a = 10;
string s = lexical_cast<string>(a);
En finesse med dette er at det støtter andre rollebesetninger også (f.eks. i motsatt retning fungerer like bra).
Legg også merke til at selv om Boost lexical_cast startet som bare å skrive til en strengstrøm, og deretter trekke tilbake ut av strømmen, har den nå et par tillegg. Først av alt, spesialiseringer for ganske mange typer har blitt lagt til, så for mange vanlige typer, det's vesentlig raskere enn å bruke en stringstream. For det andre sjekker den nå resultatet, så (for eksempel) hvis du konverterer fra en streng til en int
, kan den kaste et unntak hvis strengen inneholder noe som ikke kan konverteres til en int
(f.eks. vil 1234
lykkes, men 123abc
vil kaste).
Fra og med C++11 er det en std::to_string
-funksjon som er overbelastet for heltallstyper, slik at du kan bruke kode som:
int a = 20;
std::string s = to_string(a);
Standarden definerer disse som ekvivalente til å gjøre konverteringen med sprintf
(ved hjelp av konverteringsspesifikatoren som samsvarer med den medfølgende objekttypen, for eksempel %d
for int
), til en buffer av tilstrekkelig størrelse, og deretter opprette en std::string
av innholdet i denne bufferen.