How can I convert int to string in C++?

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)

Note: for faster/non-allocating conversions, consider the {fmt} library's fmt::format_int as per @vitaut's answer.

C++20: std::format would be the idiomatic way now.

C++17:

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

// variadic template template < typename... Args > std::string sstr( Args &&... args ) { std::ostringstream sstr; // fold expression ( sstr << std::dec << ... << args ); return sstr.str(); } 

Usage:

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

C++98:

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.

Current C++

Starting with C++11, there's a std::to_string function overloaded for integer types, so you can use code like:

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

The standard defines these as being equivalent to doing the conversion with sprintf (using the conversion specifier that matches the supplied type of object, such as %d for int), into a buffer of sufficient size, then creating an std::string of the contents of that buffer.

Old C++

For older (pre-C++11) compilers, probably the most common easy way wraps essentially your second choice into a template that's usually named lexical_cast, such as the one in Boost, so your code looks like this:

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

One nicety of this is that it supports other casts as well (e.g., in the opposite direction works just as well).

Also note that although Boost lexical_cast started out as just writing to a stringstream, then extracting back out of the stream, it now has a couple of additions. First of all, specializations for quite a few types have been added, so for many common types, it's substantially faster than using a stringstream. Second, it now checks the result, so (for example) if you convert from a string to an int, it can throw an exception if the string contains something that couldn't be converted to an int (e.g., 1234 would succeed, but 123abc would throw).

I usually use the following method:

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

It is described in details here.

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

It would be easier using stringstreams:

#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 

Or make a function:

#include <sstream> string IntToString(int a) { ostringstream temp; temp << a; return temp.str(); } 

C++ has evolved over time, and with it the methods to convert an int to a string. I will provide a summary in this answer. Note that some methods don't give you a std::string directly, but a char*. You can easily convert char* to the former, and in some cases it's beneficial to avoid std::string.

Comparison

The following table compares all options (only C++ standard options, no third-party libraries) from most recent to least recent.

Recommended Practice

Use std::to_string if you just need to turn an int into a decimal string. It's simple, elegant, and correct.

If you can't use std::to_string, choose another option based on the features you need. Prefer more modern solutions like std::to_chars over older solutions like std::sprintf.

Examples

std::format

std::string d = std::format("{}", 100); // d = "100" std::string h = std::format("{:#x}", 15); // h = "0xf" 

std::to_chars

std::array<char, 5> a; auto [ptr, ec] = std::to_chars(a.data(), a.data() + a.size(), 1234); // a = {'1', '2', '3', '4', indeterminate} (no null terminator!) // ptr points to 4, and ec == std::errc{} // notice that there is no null terminator std::string_view view(a.data(), ptr); // string_view doesn't require null terminators std::string s(a.data(), ptr); // wrapping in a std:string kinda defeats the point 

std::to_string

std::string d = std::to_string(100); // d = "100" 

std::ostringstream

std::string d = (std::ostringstream() << 100).str(); // d = "100" std::string h = (std::ostringstream() << std::hex << 15).str(); // h = "0xf" 

Note: these one-liners rely on LWG 1203 (C++20), but recent compilers allow it in C++11 mode too. Update your compiler, or create a separate std::ostringstream stream variable if it doesn't work.

sprintf / snprintf

char a[20]; sprintf(a, "%d", 15); // a = {'1', '5', '\0', ?, ?, ?, ...} snprintf(a, sizeof(a), "%#x", 15); // a = {'0', 'x', 'f', '\0', ?, ?, ...} std::string s = a; 

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 std::ostream::operator<< where it tells that operator<< inserts formatted output.

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

E.g., int = 1000 could be converted 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.

From std::to_string:

C++17 provides std::to_chars as a higher-performance locale-independent alternative.

First include:

#include <string> #include <sstream> 

Second add the method:

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

Use the method like this:

NumberToString(69); 

or

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

In C++11 we can use the "to_string()" function to convert an int into a string:

#include <iostream> #include <string> int main() { int x = 1612; std::string s = std::to_string(x); std::cout << s << std::endl; return 0; } 

C++17 provides std::to_chars as a higher-performance locale-independent alternative.

If you need fast conversion of an integer with a fixed number of digits to char* left-padded with '0', this is the example for little-endian architectures (all x86, x86_64 and others):

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. In this example n is a given integer. After conversion it's string representation can be accessed as (char*)&s:

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

Note: If you need it on big-endian byte order, though I did not tested it, but here is an example: for three-digit number it is int32_t s = 0x00303030 | (n/100)<< 24 | (n/10%10)<<16 | (n%10)<<8; for four-digit numbers (64 bit arch): int64_t s = 0x0000000030303030 | (n/1000)<<56 | (n/100%10)<<48 | (n/10%10)<<40 | (n%10)<<32; I think it should work.

It's rather easy to add some syntactical sugar that allows one to compose strings on the fly in a stream-like way

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

Now you may append whatever you want (provided that an operator << (std::ostream& ..) is defined for it) to strmake() and use it in place of an std::string.

Example:

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

int i = 255; std::string s = std::to_string(i); 

In C++, to_string() will create a string object of the integer value by representing the value as a sequence of characters.

C++11 introduced std::to_string() for numeric types:

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

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're using the Microsoft Foundation Class library, you can use CString:

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

Use:

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

Here's another easy way to do it:

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

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

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

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