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();
This question is related to
c++
string
int
type-conversion
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.
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);
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.
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.
char * bufSecs = new char[32];
char * bufMs = new char[32];
sprintf(bufSecs, "%d", timeStart.elapsed()/1000);
sprintf(bufMs, "%d", timeStart.elapsed()%1000);
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;
}
sprintf()
is pretty good for format conversion. You can then assign the resulting C string to the C++ string as you did in 1.
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
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)
.
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 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.
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 std::to_string
on Boost Karma benchmarks. See Converting a hundred million integers to strings per second for more details.
Note that both are thread-safe.
Unlike std::to_string
, fmt::format_int
doesn't require C++11 and works with any C++ compiler.
Disclaimer: I'm the author of the {fmt} library.
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.
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).
Use:
#define convertToString(x) #x
int main()
{
convertToString(42); // Returns const char* equivalent of 42
}
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.
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]
C++17 provides std::to_chars
as a higher-performance locale-independent alternative.
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;
}
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!."
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;
}
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;
}
For C++98, there's a few options:
boost/lexical_cast
Boost is not a part of the C++ library, but contains many useful library extensions.
The
lexical_cast
function template offers a convenient and consistent form for supporting common conversions to and from arbitrary types when they are represented as text.
-- Boost's Documentation
#include "boost/lexical_cast.hpp"
#include <string>
int main() {
int x = 5;
std::string x_str = boost::lexical_cast<std::string>(x);
return 0;
}
As for runtime, the lexical_cast
operation takes about 80 microseconds (on my machine) on the first conversion, and then speeds up considerably afterwards if done redundantly.
itoa
This function is not defined in ANSI-C and is not part of C++, but is supported by some compilers.
-- cplusplus.com
This means that gcc
/g++
cannot compile code using itoa
.
#include <stdlib.h>
int main() {
int x = 5;
char * x_str = new char[2];
x_str = itoa(x, x_str, 10); // base 10
return 0;
}
No runtime to report. I don't have Visual Studio installed, which is reportedly able to compile itoa
.
sprintf
sprintf
is a C standard library function that works on C strings, and is a perfectly valid alternative.
Composes a string with the same text that would be printed if format was used on printf, but instead of being printed, the content is stored as a C string in the buffer pointed by str.
-- cplusplus.com
#include <stdio.h>
int main() {
int x = 5;
char * x_str = new char[2];
int chars_written = sprintf(x_str, "%d", x);
return 0;
}
The stdio.h
header may not be necessary. As for runtime, the sprintf
operation takes about 40 microseconds (on my machine) on the first conversion, and then speeds up considerably afterwards if done redundantly.
stringstream
This is the C++ library's main way of converting integers to strings, and vice versa. There are similar sister functions to stringstream
that further limit the intended use of the stream, such as ostringstream
. Using ostringstream
specifically tells the reader of your code that you only intend to use the <<
operator, essentially. This function is all that's particularly necessary to convert an integer to a string. See this question for a more elaborate discussion.
#include <sstream>
#include <string>
int main() {
int x = 5;
std::ostringstream stream;
stream << x;
std::string x_str = stream.str();
return 0;
}
As for runtime, the ostringstream
operation takes about 71 microseconds (on my machine), and then speeds up considerably afterwards if done redundantly, but not by as much as the previous functions.
Of course there are other options, and you can even wrap one of these into your own function, but this offers an analytical look at some of the popular ones.
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.
If you're using MFC, you can use CString
:
int a = 10;
CString strA;
strA.Format("%d", a);
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;
}
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
I know 950 is too small to use as an example, but I hope you get the idea.
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
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.
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();
}
Source: Stackoverflow.com