ChatGPT解决这个技术问题 Extra ChatGPT

Easiest way to convert int to string in C++

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();
I think both methods you gave are good solutions. it depends on the context where you need to do it. If you're already working with streams, for example reading or writing a file, then your second method is the best. If you need to pass an int as a string to a function argument, then itoa could be an easy way. But most of the time, int to string conversion occurs when dealing with files, so streams are appropriate.
How does option 1 even work for you at all? It's my understanding that itoa() takes three parameters.
itoa will be faster than the stream equivalent. There are also ways of re-using the string buffer with the itoa method (avoiding heap allocations if you are frequently generating strings. e.g. for some rapidly updating numerical output). Alternatively you can generate a custom streambuf to reduce some of the allocation overhead etc. Constructing the stream in the first place is also not a low cost venture.
@Pete: Once you start worrying about which is faster, you'll want to look at stackoverflow.com/questions/4351371/…
Note that itoa() is not part of the standard and therefore using it renders your code not portable since not all compilers support it. For Linux you are most certainly out unless you are using something else than GCC, which does not support this function. If you have C++0x, go with what @Matthieu has suggested in his answer. If that's not the case, go with stringstream since it is a well supported feature and your code should be compatible with every C++ compiler out there. As an alternative you can always go with sprintf().

t
the_storyteller

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)


to_string not a member of std fix: stackoverflow.com/questions/12975341/…
Or depending on your compiler, just set the right language standard: g++ -std=c++11 someFile.cc
@Steve: it's supposed to be. It's a member of std in every compiler I know of except for one.
@Matthiew M. I am using the same which you suggest but i am getting this error : Error : No instance of overloaded function "std::to_string" matches the argument list i am using VS2010 c++
@Flying: under VS2010 you have to explicitly cast the converting integer to one of the following types [_Longlong, _ULonglong, long double]; i.e: string s = to_string((_ULonglong)i);
D
DevSolar

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.


I am not very familiar with dynamic_cast but I am using clang to compile so it complains about it. If I just omit the dynamic_cast then it compiles fine; what purpose does the dynamic_cast serve in this case? We are already creating an ostringstream, so why cast it?
@Mathew: The link in my answer leads to a detailed description of each part of the construct. While we created a ostringstream, we called operator<<() on it, which returns ostream & -- for which .str() is not defined. I really wonder how clang would make this work without the cast (or why it generates an error with it). This construct is published in many places, and I've used it for over a decade on many different compilers, including MSVC, GCC, and XLC, so I am rather surprised clang balks at it.
Just came to the party for curiosity, and downvoted. Reason : too much votes for a solution that's un-elegant, and likely slow. 1. macro usage. I don't systematically frown on any macro, but this one is too short, and end-clients always fear repetition of the argument, on top of fear for unprotected multilines macros. (not protected by do{}while(0)) 2. dynamic_cast. it seems you only need a static_cast here, unless you want to assert that the library indeed is implemented as you hope. in which case you should use boost::polymorphic_downcast instead.
@v.oddou: You're free to critizise, of course. But 1. is invalid -- the macro is a single statement, do { } while( 0 ) would not add anything. With 2. and 3. you probably got a point -- this could be done with a static cast, and perhaps one of you template wizards out there could come up with a "nicer" interface. But as I said, this is by no means an invention of myself. Look around, this macro (macro!) is quite ubiquitous. That's a case of POLA in itself. I might toy with this a bit to make it more "streamlined".
@v.oddou: Look at what I found among the things C++17 brought us. :-) I hope you like the updated answer.
J
Jerry Coffin

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


Nice, I prefer Kevin's answer, though as he shows the include and namespace. Just a minor gripe. :) Good job, though!
I'd say this is the way to go if you don't have C++11 support.
P
Peter Mortensen

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.


@lifebalance: I have never seen such behavior.
@lifebalance: You do not need to clear() a newly created ostringstream object. clear() resets the error/eof flags, and there has not been any error/eof condition generated yet.
@Rasoul NumberToString(23213.123) produces 23213.1 while std::to_string(23213.123) produces 23213.123000 What happens there?
@KillzoneKid This is because std' ostream are stateful (this means that any previous state change is kept, like the number of decimal digit) while this method starts with a default state.
Use .flags(...) to read & clear formatting flags, and .str("") to clear an existing string.
v
vitaut

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.


I was curious about the claim of not having any dynamic memory allocation while remain threadsafe (re-entrant), so I read your code -- the c_str() returns a pointer to a buffer declared inside the fmt::FormatInt class -- so the pointer returned will be invalid at the semicolon -- see also stackoverflow.com/questions/4214153/lifetime-of-temporaries
Yes, the same behavior as with std::string::c_str() (thus the naming). If you want to use it outside of the full expression construct an object FormatInt f(42); Then you can use f.c_str() without a danger of it being destroyed.
I get something weird when I try to convert from int to string using std::to_string(num). If I store the result in a variable and try to Access it like stringNum[1] or stringNum[n] as n increases, I get garbage.
That's definitively the right answer to this question: efficient and standard code that's not stateful.
K
Kevin

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

Agreed on boost installation. I think that more than often one would format the string. For this purpose I prefer boost::format e.g format("%02d", number ).str()
P
Peter Mortensen

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

u
user541686

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.


itoa() is not a standard function!
@cartoonist: Then what is it?
This function is not defined in ANSI-C and C++. So it's not supported by some compiler such as g++.
cplusplus.com/reference/cstdlib/itoa: "Portability This function is not defined in ANSI-C and is not part of C++, but is supported by some compilers." gcc.godbolt.org/z/MaEEf4evW
b
bluish

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


Heh, yes. However, I usually rely on snprintf() and friends for anything of consequence when handling C strings.
@MatthieuM. Your comment proves further, that you are not. If the output was truncated due to this limit then the return value is the number of characters (excluding the terminating null byte) which would have been written to the final string if enough space had been available. Thus, a return value of size or more means that the output was truncated. So you call it with a NULL and zero size to get the necessary buffer size.
@user1095108: I think you are mistaking snprintf (note the SNP prefix) and sprintf (note the SP prefix). You pass the size to the former, and it takes care not to overflow, however the latter knows not the size of the buffer and thus may overflow.
The idea is to call a snprintf variant first and a sprintf variant after that. As the buffer size is known by then, calling sprintf becomes entirely safe.
@user1095108 Ah, yes. If the first buffer to snprintf is insufficient, the return value tells you what would be sufficient. I would still use snprintf for the second call, because relying on the implementations of sprintf and snprintf to match is unnecessarily dangerous.
q
quamrana

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

Y
YesThatIsMyName

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 agree that this is a serious problem if you need to exchange data. Unfortunately, also std::to_string uses the current locale (see en.cppreference.com/w/cpp/string/basic_string/to_string , the 'Notes' section). Almost all standard tools (from stringstreams to sprintf, but also sscanf etc) are using the current locale. I wasn't aware of this until recently when it hit me hard. Currently using home-grown stuff, not hard to make.
In the link above it is also statet that C++17 provides std::to_chars as a higher-performance locale-independent alternative.
Unfortunately, I am stuck with C++11 for the coming year(s) (quite an improvement already, luckily).
from_chars and to_chars would be perfect but unfortunately they didn't offer a wchar_t variant.
W
Waqar

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


For performance intensive applications you need this one and not the stringstream route.
M
Manish Kumawat

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

A
Alek

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.


What about byte-order?
@shjeff thanks for the comment, I added a note on endianness to the answer.
@dgnuff thanks for pointing this out, although I've had no problems with this, you are right. I slightly modified the answer so that it complies Strict Aliasing Rules, thanks.
A
AndreyS Scherbakov

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

i
isanae

Use:

#define convertToString(x) #x

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

Works only with literal numbers, doesn't evaluate variable content, though useful sometimes.
Right. But definitely handy at time
Only works at compile time with literal constants numbers, i think the OP asks for a dynamic conversion, using variable integers
P
Peter Mortensen

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.


P
Peter Mortensen

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.


T
Tur1ng

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

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

You should note that this is a Microsoft-only extension: msdn.microsoft.com/en-us/library/ms174288.aspx
I love the idea of CString::Format(). Unfortunate it it non portable MS only.
I have updated my answer to include the information from your comment @JonnyJD, since I keep getting downvoted for it 5 years later..
K
Kotauskas

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

Hi! Could you add an explanation on why and how this provides an answer to the question?
P
Peter Mortensen
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;
}

Thank you for this code snippet, which might provide some limited short-term help. A proper explanation would greatly improve its long-term value by showing why this is a good solution to the problem, and would make it more useful to future readers with other, similar questions. Please edit your answer to add some explanation, including the assumptions you've made.
Completely fails for n≤0
Add comments, explain your answer, read how to answer.
P
Peter Mortensen

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

Essentially using what? stringstream?
@PeterMortensen Look carefully, it's std::to_string()
i have using namespace std; :)
A
Archie

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.


While this code may resolve the OP's issue, it is best to include an explanation as to how your code addresses the OP's issue. In this way, future visitors can learn from your post, and apply it to their own code. SO is not a coding service, but a resource for knowledge. Also, high quality, complete answers are more likely to be upvoted. These features, along with the requirement that all posts are self-contained, are some of the strengths of SO as a platform, that differentiates it from forums. You can edit to add additional info &/or to supplement your explanations with source documentation.
P
PYK

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]


While I like your answer, it is incorrect: you forgot the null-character to mark the ending of the converted string (i.e., the size of the output string must be, at least, 3 in this case). See gnu.org/software/libc/manual/html_node/…
T
Tayyab Mazhar

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

Completely fails for n≤0
P
Peter Mortensen
char * bufSecs = new char[32];
char * bufMs = new char[32];
sprintf(bufSecs, "%d", timeStart.elapsed()/1000);
sprintf(bufMs, "%d", timeStart.elapsed()%1000);

leaks memory, -1 from me
This smells like buffer overrun.
P
Peter Mortensen
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).


While this solution works, it is highly discouraged! Names starting with underscore and a capital letter are reserved for the compiler, you shouldn't ever use them. Injecting functions into the std namespace is not something you should ever do, either. Also, it doesn't seem like _MAX_INT_DIG is a standard macro, so if it is defined wrongly, this code has the great potential of inducing undefined behaviour. -1
What is _MAX_INT_DIG and why is it doubled?
P
Peter Mortensen

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.

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.


It's not very helpful to describe an algorithm, rather than show an example in code.
P
Peter Mortensen

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

This was mentioned in the question, and unfortunately is quite slow.