在C++中将int转换为字符串的最简单方法

据我所知不是纯粹的C++但是对你提到的做了一点修改

string s = string(itoa(a));

应该工作，而且很短。

C++20：圣d::f奥马特现在是惯用的方式。

C++17：

几年后，C++17与@v.oddou进行了讨论，提供了一种方法来执行最初基于宏的类型无关解决方案（保留在下面）没有通过宏丑陋。

// variadic templatetemplate < typename... Args >std::string sstr( Args &&... args ){std::ostringstream sstr;// fold expression( sstr << std::dec << ... << args );return sstr.str();}

用法：

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

C++98：

由于“转换…到字符串”是一个反复出现的问题，我总是在我的C++源代码的中心标头中定义SSTR（）宏：

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

用法尽可能简单：

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

上述C++98兼容（如果您不能使用C++11std::to_string），并且不需要任何第三方包含（如果您不能使用Boostlexical_cast<>）；这两种其他解决方案都具有更好的性能。

当前C++

从C++11开始，有一个std::to_string函数重载了整数类型，因此您可以使用以下代码：

int a = 20;std::string s = std::to_string(a);// or: auto s = std::to_string(a);

标准将这些定义为等价于使用sprintf（使用与提供的对象类型匹配的转换说明符，例如%d表示int）进行转换，转换为足够大的缓冲区，然后创建该缓冲区内容的std::string。

老C++

对于较旧的编译器（前C++11），可能最常见的简单方法是将您的第二选择包装到通常名为lexical_cast的模板中，例如Boost中的模板，因此您的代码如下所示：

int a = 10;string s = lexical_cast<string>(a);

其中一个优点是它也支持其他转换（例如，在相反的方向上也可以工作）。

另请注意，尽管Boostlexical_cast一开始只是写入stringstream，然后从流中提取回来，但它现在有一些添加。首先，添加了相当多类型的特化，因此对于许多常见类型，它比使用stringstream快得多。其次，它现在检查结果，因此（例如）如果您从字符串转换为int，如果字符串包含无法转换为int的内容，它可以抛出异常（例如，1234会成功，但123abc会抛出）。

sprintf()非常适合格式转换。然后，您可以将生成的C字符串分配给C++字符串，就像在1中所做的那样。

如果您安装了Boost（您应该安装）：

#include <boost/lexical_cast.hpp>
int num = 4;std::string str = boost::lexical_cast<std::string>(num);

C++11引入了#0（以及每个数字类型的变体）和#1，Catoi和itoa的对应物，但以std::string表示。

#include <string>
std::string s = std::to_string(42);

因此，这是我能想到的最短的方法。你甚至可以省略命名类型，使用auto关键字：

auto s = std::to_string(42);

注：见[string.conversions]（21.5inn3242）

我通常使用以下方法：

#include <sstream>
template <typename T>std::string NumberToString ( T Number ){std::ostringstream ss;ss << Number;return ss.str();}

在细节这里中描述。

char * bufSecs = new char[32];char * bufMs = new char[32];sprintf(bufSecs, "%d", timeStart.elapsed()/1000);sprintf(bufMs, "%d", timeStart.elapsed()%1000);

namespace std{inline string to_string(int _Val){   // Convert long long to stringchar _Buf[2 * _MAX_INT_DIG];snprintf(_Buf, "%d", _Val);return (string(_Buf));}}

您现在可以使用to_string(5)。

使用字符串流会更容易：

#include <sstream>
int x = 42;          // The integerstring str;          // The stringostringstream temp;  // 'temp' as in temporarytemp << x;str = temp.str();    // str is 'temp' as string

或者做一个函数：

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

首先包括：

#include <string>#include <sstream>

第二添加方法：

template <typename T>string NumberToString(T pNumber){ostringstream oOStrStream;oOStrStream << pNumber;return oOStrStream.str();}

使用这样的方法：

NumberToString(69);

或

int x = 69;string vStr = NumberToString(x) + " Hello word!."

我使用：

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

它适用于我的Windows和Linuxg++编译器。

如果你使用MFC，你可以使用CString：

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

您可以使用C++11中可用的std::to_string作为由Matthieu M.：

std::to_string(42);

或者，如果性能至关重要（例如，如果您进行了大量转换），您可以使用{fmt}库中的fmt::format_int将整数转换为std::string：

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

或者一个C字符串：

fmt::format_int f(42);f.c_str();

后者不做任何动态内存分配，并且在Boost Karma基准测试上比std::to_string的libstdc++实现快70%以上。有关更多详细信息，请参阅每秒将一亿个整数转换为字符串。

免责声明：我是{fmt}库的作者。

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

用途：

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

您使用计数器类型的算法来转换为字符串。我从编程Commodore 64计算机中获得了这种技术。它也适用于游戏编程。

• 您取整数并取每个以10的幂加权的数字。所以假设整数是950。

  • 如果整数等于或大于100,000，则减去100,000并将字符串中的计数器增加到["000000"]；
    继续这样做，直到位置100,000中不再有数字。再放一个10的幂。

  • 如果整数等于或大于10,000，则减去10,000并在["000000"]+1位置增加字符串中的计数器；
    一直这样做，直到没有更多的数字在位置10,000。

• 再放一个10的幂

• 重复这个模式

我知道950太小了，不能用作例子，但我希望你能明白。

如果需要将固定位数的整数快速转换为char*用“0”填充，这是little-endian架构（所有x86、x86_64等）的示例：

如果您正在转换两位数：

int32_t s = 0x3030 | (n/10) | (n%10) << 8;

如果您正在转换三位数：

int32_t s = 0x303030 | (n/100) | (n/10%10) << 8 | (n%10) << 16;

如果您正在转换一个四位数：

int64_t s = 0x30303030 | (n/1000) | (n/100%10)<<8 | (n/10%10)<<16 | (n%10)<<24;

等等，直到七位数。在这个例子中，n是一个给定的整数。转换后，它的字符串表示可以作为(char*)&s访问：

std::cout << (char*)&s << std::endl;

说明：如果你需要它在大端字节顺序，虽然我没有测试它，但这里有一个例子：对于三位数，它是int32_t s = 0x00303030 | (n/100)<< 24 | (n/10%10)<<16 | (n%10)<<8;为四位数（64位拱）：int64_t s = 0x0000000030303030 | (n/1000)<<56 | (n/100%10)<<48 | (n/10%10)<<40 | (n%10)<<32;我认为它应该工作。

使用字符串流进行数字转换是危险的！

请参见std::ostream::操作符<<，它告诉operator<<插入格式化输出。

根据您当前的语言环境，大于三位数的整数可以转换为四位数的字符串，并添加额外的千位分隔符。

例如，int = 1000可以转换为字符串1.001。这可能会使比较操作根本不起作用。

所以我强烈推荐使用#0的方法。它更容易，也能满足你的期望。

从std::to_string：

C++17提供std::to_chars作为更高性能的独立于语言环境的替代方案。

添加一些语法糖是相当容易的，它允许人们以流的方式动态地组合字符串

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

现在，您可以将您想要的任何内容（前提是为其定义了运算符<< (std::ostream& ..)）附加到strmake()并使用它来代替std::string。

示例：

#include <iostream>
int main() {std::string x =strmake() << "Current time is " << 5+5 << ":" << 5*5 << " GST";std::cout << x << std::endl;}

这是另一个简单的方法

char str[100];sprintf(str, "%d", 101);string s = str;

sprintf是将任何数据插入所需格式的字符串的众所周知的方法。

您可以将char *数组转换为字符串，如第三行所示。

用途：

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

C++11为数字类型引入了#0：

int n = 123; // Input, signed/unsigned short/int/long/long long/float/doublestd::string str = std::to_string(n); // Output, std::string

我认为使用stringstream很容易：

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

C++17提供#0作为更高性能的独立于语言环境的替代方案。

这对我有用-

我的代码：

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

int i = 255;std::string s = std::to_string(i);

在C++，to_string（）将通过将值表示为字符序列来创建整数值的字符串对象。

使用普通标准标准输入输出头，您可以将spintf上的整数转换为缓冲区，如下所示：

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

请记住根据您的需要（字符串输出大小）照顾您的缓冲区大小。

在C++11中，我们可以使用to_string（）函数将int转换为字符串：

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

您所要做的就是在定义变量（String intStr）时使用String。每当您需要该变量时，调用whateverFunction(intStr.toInt())