c++ - float - to_string is not a member of std

Easiest way to convert int to string in C++ (17)

What is the easiest way to convert from int to equivalent string in C++. I am aware of two methods. Is there any easier way?


int a = 10;
char *intStr = itoa(a);
string str = string(intStr);


int a = 10;
stringstream ss;
ss << a;
string str = ss.str();

Here's another easy way to do

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

sprintf is a well known one to insert any data into a string of required format .

You can convert char * array to string as shown in the third line.

sprintf() is pretty good for format conversion. You can then assign the resulting C string to the C++ string as you did in 1.

Using stringstream for number conversion is dangerous!

See http://www.cplusplus.com/reference/ostream/ostream/operator%3C%3C/ where it tells that operator<< inserts formatted output.

Depending on your current locale an integer greater than 3 digits, could convert to a string of 4 digits, adding an extra thousands separator.

E.g., int = 1000 could be convertet to a string 1.001. This could make comparison operations not work at all.

So I would strongly recommend using the std::to_string way. It is easier and does what you expect.

C++11 introduces std::stoi (and variants for each numeric type) and std::to_string, the counterparts of the C atoi and itoa but expressed in term of std::string.

#include <string> 

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

is therefore the shortest way I can think of. You can even omit naming the type, using the auto keyword:

auto s = std::to_string(42);

Note: see [string.conversions] (21.5 in n3242)

I think, using stringstream is pretty easy.

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

 int main()
    int n;
    return 0;

I use:

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

It works on my windows and linux g++ compilers.

If you have Boost installed (which you should):

#include <boost/lexical_cast.hpp>

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

If you need fast conversion of an integer with a fixed number of digits to char* left-padded with '0', this is a convenient example:

int n = 27;
char s[8];

If you are converting a two-digit number:

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

If you are converting a three-digit number:

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

If you are converting a four-digit number:

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

And so on up to seven-digit numbers :)

Not that I know of, in pure C++. But a little modification of what you mentioned

string s = string(itoa(a));

should work, and it's pretty short.

Picking up a discussion with @v.oddou a couple of years later, C++17 has finally delivered a way to do the originally macro-based type-agnostic solution (preserved below) without going through macro uglyness.

template < typename... Args >
std::string sstr( Args &&... args )
    std::ostringstream sstr;
    ( sstr << std::dec << ... << args );
    return sstr.str();


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:

Since "converting ... to string" is a recurring problem, I always define the SSTR() macro in a central header of my C++ sources:

#include <sstream>

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

Usage is as easy as could be:

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

The above is C++98 compatible (if you cannot use C++11 std::to_string), and does not need any third-party includes (if you cannot use Boost lexical_cast<>); both these other solutions have a better performance though.


#define convertToString(x) #x

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

Using CString:

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

You can use std::to_string available in C++11 as suggested by Matthieu M.:


Or, if performance is critical (for example, if you do lots of conversions), you can use fmt::FormatInt from the C++ Format library to convert an integer to std::string:


Or a C string:

fmt::FormatInt f(42);

The latter doesn't do any dynamic memory allocations and is more than 10 times faster than std::to_string on Boost Karma benchmarks. See Fast integer to string conversion in C++ for more details.

Unlike std::to_string, fmt::FormatInt doesn't require C++11 and works with any C++ compiler.

Disclaimer: I'm the author of the C++ Format library.

You use a counter type of algorithm to convert to a string. I got this technique from programming Commodore 64 computers. It is also good for game programming.

  • You take the integer and take each digit that is weighted by powers of 10. So assume the integer is 950.

    • If the integer equals or is greater than 100,000 then subtract 100,000 and increase the counter in the string at ["000000"];
      keep doing it until no more numbers in position 100,000. Drop another power of ten

    • If the integer equals or is greater than 10,000 then subtract 10,000 and increase the counter in the string at ["000000"] + 1 position;
      keep doing it until no more numbers in position 10,000.

  • Drop another power of ten

  • Repeat pattern

I know 950 is too small to use as an example but I hope you get the idea.

char * bufSecs = new char[32];
char * bufMs = new char[32];

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

string number_to_string(int x){
    if(!x) return "0";
        string s,s2;
            s.push_back(x%10 + '0');
    return s;