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

Question

How can I convert from int to the equivalent string in C++? I am aware of two methods. Is there another way?

(1)

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

(2)

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

Answer 1

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.

Answer 2

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.

Answer 3

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

Answer 4

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.

Answer 5

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

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

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

std::string s = fmt::format_int(42).str();

Or a C string:

fmt::format_int f(42);
const char* s = f.c_str();

The latter doesn't do any dynamic memory allocations and is more than 70% faster than libstdc++ implementation of std::to_string on Boost Karma benchmarks. See Converting a hundred million integers to strings per second for more details.

Disclaimer: I'm the author of the {fmt} library.

Answer 6

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

Answer 7

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

Answer 8

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.

Method	Result	Pros & Cons
std::format c++20	std::string	✔️ universal method (for formattable types) ✔️ supports common bases, and locale ❌ slow to compile ❌ slow (forward to std::vformat)
std::to_chars c++17	written to char[]	✔️ fast and zero overhead (no dynamic allocations) ✔️supports ANY base as run-time argument ❌ only works for fundamental types ❌ interface is not ergonomic
std::to_string c++11	std::string	✔️ concise and self-explanatory ✔️ zero overhead (if you need a std::string) ❌ only works for fundamental types ❌ base 10 only
std::ostringstream c++98	std::string	✔️ universal method (for types with << operator) ✔️ considers locale (e.g. can change base) ❌ slow, and high overhead of streams
std::sprintf c++98	written to char[]	✔️ smallest assembly output ✔️ supports some bases ✔️ compatible with C, unlike all other methods ❌ only works for fundamental types ❌ interface is not ergonomic ❌ no type safety

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;

Answer 9

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

Answer 10

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.

Answer 11

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!."

Answer 12

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

Answer 13

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

Answer 14

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.

Answer 15

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

Answer 16

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.

Answer 17

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

Answer 18

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.

Answer 19

If you're using the Microsoft Foundation Class library, you can use CString:

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

Answer 20

Use:

#define convertToString(x) #x

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

Answer 21

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.

Answer 22

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

Answer 23

All you have to do is use String when defining your variable (String intStr). Whenever you need that variable, call whateverFunction(intStr.toInt())

Answer 24

namespace std
{
    inline string to_string(int _Val)
    {   // Convert long long to string
        char _Buf[2 * _MAX_INT_DIG];
        snprintf(_Buf, "%d", _Val);
        return (string(_Buf));
    }
}

You can now use to_string(5).