Easiest way to convert int to string in C++
C++StringIntType ConversionC++ Problem Overview
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();
C++ Solutions
Solution 1 - 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)
Solution 2 - C++
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.
Solution 3 - C++
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.
Solution 4 - C++
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).
Solution 5 - C++
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);
Solution 6 - C++
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.
Solution 7 - C++
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();
}
Solution 8 - C++
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.
Solution 9 - C++
sprintf()
is pretty good for format conversion. You can then assign the resulting C string to the C++ string as you did in 1.
Solution 10 - C++
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!."
Solution 11 - C++
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.
Updated (see comments below):
> C++17 provides std::to_chars
as a higher-performance
> locale-independent alternative
Solution 12 - C++
C++17 provides std::to_chars
as a higher-performance locale-independent alternative.
Solution 13 - C++
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.
Solution 14 - C++
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;
}
Solution 15 - C++
Use:
#define convertToString(x) #x
int main()
{
convertToString(42); // Returns const char* equivalent of 42
}
Solution 16 - C++
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;
}
Solution 17 - C++
C++11 introduced [std::to_string()
][1] 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]: https://en.cppreference.com/w/cpp/string/basic_string/to_string "Article at cppreference.com"
Solution 18 - C++
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.
Solution 19 - C++
If you're using MFC, you can use CString
:
int a = 10;
CString strA;
strA.Format("%d", a);
Solution 20 - C++
> 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.
Solution 21 - C++
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;
}
Solution 22 - C++
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;
}
Solution 23 - C++
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.
Solution 24 - C++
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]
Solution 25 - C++
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;
}
Solution 26 - C++
char * bufSecs = new char[32];
char * bufMs = new char[32];
sprintf(bufSecs, "%d", timeStart.elapsed()/1000);
sprintf(bufMs, "%d", timeStart.elapsed()%1000);
Solution 27 - C++
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)
.
Solution 28 - C++
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;
}
Solution 29 - C++
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.