Converting an int to std::string

#include <sstream> #include <string> const int i = 3; std::ostringstream s; s << i; const std::string i_as_string(s.str()); 

Well, the well known way (before C++11) to do that is using the stream operator :

#include <sstream> std::ostringstream s; int i; s << i; std::string converted(s.str()); 

Of course, you can generalize it for any type using a template function ^^

#include <sstream> template<typename T> std::string toString(const T& value) { std::ostringstream oss; oss << value; return oss.str(); } 

boost::lexical_cast<std::string>(yourint) from boost/lexical_cast.hpp

Work's for everything with std::ostream support, but is not as fast as, for example, itoa

It even appears to be faster than stringstream or scanf:

• http://www.boost.org/doc/libs/1_53_0/doc/html/boost_lexical_cast/performance.html

If you cannot use std::to_string from C++11, you can write it as it is defined on cppreference.com:

std::string to_string( int value ) Converts a signed decimal integer to a string with the same content as what std::sprintf(buf, "%d", value) would produce for sufficiently large buf.

Implementation

#include <cstdio> #include <string> #include <cassert> std::string to_string( int x ) { int length = snprintf( NULL, 0, "%d", x ); assert( length >= 0 ); char* buf = new char[length + 1]; snprintf( buf, length + 1, "%d", x ); std::string str( buf ); delete[] buf; return str; } 

You can do more with it. Just use "%g" to convert float or double to string, use "%x" to convert int to hex representation, and so on.

Non-standard function, but its implemented on most common compilers:

int input = MY_VALUE; char buffer[100] = {0}; int number_base = 10; std::string output = itoa(input, buffer, number_base); 

Update

C++11 introduced several std::to_string overloads (note that it defaults to base-10).

The following macro is not quite as compact as a single-use ostringstream or boost::lexical_cast.

But if you need conversion-to-string repeatedly in your code, this macro is more elegant in use than directly handling stringstreams or explicit casting every time.

It is also very versatile, as it converts everything supported by operator<<(), even in combination.

Definition:

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

Explanation:

The std::dec is a side-effect-free way to make the anonymous ostringstream into a generic ostream so operator<<() function lookup works correctly for all types. (You get into trouble otherwise if the first argument is a pointer type.)

The dynamic_cast returns the type back to ostringstream so you can call str() on it.

Use:

#include <string> int main() { int i = 42; std::string s1 = SSTR( i ); int x = 23; std::string s2 = SSTR( "i: " << i << ", x: " << x ); return 0; } 

You can use this function to convert int to std::string after including <sstream>:

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

While std::to_string is a straightforward tool that should be kept in mind, starting with C++20, you may include <format>, which allows for more elaborates conversations from int to string:

#include <iostream> #include <locale> #include <format> int main() { using std::cout, std::endl; auto const n = 42; cout << std::format("{}", n) << endl; cout << std::format("{:d}", n) << endl; cout << std::format("{:#x}", n) << endl; cout << std::format("{:#o}", n) << endl; cout << std::format("{:#b}", n) << endl; } 

output:

42 42 0x2a 052 0b101010 

You might include the implementation of itoa in your project.
Here's itoa modified to work with std::string: http://www.strudel.org.uk/itoa/