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?

(1)

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

(2)

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

29 Answers

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)

20

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

C++17 update:

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.

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

Original (C++98) 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.

10

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

2

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.

7

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

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:

fmt::format_int(42).str();

Or a C string:

fmt::format_int f(42); 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.

4

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

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

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.

4

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

9

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

Using stringstream for number conversion is dangerous!

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

Updated (see comments below):

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

4

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

1

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

3

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

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

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

Use:

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

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.

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 the required format.

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

0

If you're using MFC, you can use CString:

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

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

This worked for me -

My code:

#include <iostream> using namespace std; int main() { int n = 32; string s = to_string(n); cout << "string: " + s << endl; return 0; }
3

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.

1

Using the plain standard stdio header, you can cast the integer over sprintf into a buffer, like so:

#include <stdio.h> int main() { int x=23; char y[2]; //the output buffer sprintf(y,"%d",x); printf("%s",y) }

Remember to take care of your buffer size according to your needs [the string output size]

1

Use:

#include<iostream> #include<string> std::string intToString(int num); int main() { int integer = 4782151; std::string integerAsStr = intToString(integer); std::cout << "integer = " << integer << std::endl; std::cout << "integerAsStr = " << integerAsStr << std::endl; return 0; } std::string intToString(int num) { std::string numAsStr; bool isNegative = num < 0; if(isNegative) num*=-1; do { char toInsert = (num % 10) + 48; numAsStr.insert(0, 1, toInsert); num /= 10; }while (num); return isNegative? numAsStr.insert(0, 1, '-') : numAsStr; }
1
char * bufSecs = new char[32]; char * bufMs = new char[32]; sprintf(bufSecs, "%d", timeStart.elapsed()/1000); sprintf(bufMs, "%d", timeStart.elapsed()%1000);
2
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).

2

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 the pattern

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

1

I think using stringstream is pretty easy:

 string toString(int n) { stringstream ss(n); ss << n; return ss.str(); } int main() { int n; cin >> n; cout << toString(n) << endl; return 0; }
1