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

在C ++中从int转换为等效string的最简单方法是什么。 我知道两种方法。 有没有更简单的方法？

（1）

int a = 10;
char *intStr = itoa(a);
string str = string(intStr);

（2）

int a = 10;
stringstream ss;
ss << a;
string str = ss.str();

---

#1楼

我通常使用以下方法：

#include 

template 
  std::string NumberToString ( T Number )
  {
     std::ostringstream ss;
     ss << Number;
     return ss.str();
  }

在此进行详细说明。

---

#2楼

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

---

#3楼

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

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

---

#4楼

使用stringstreams会更容易：

#include 

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

或做一个功能：

#include 

string IntToString(int a)
{
    ostringstream temp;
    temp << a;
    return temp.str();
}

---

#5楼

首先包括：

#include 
#include 

第二种添加方法：

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

使用如下方法：

NumberToString(69);

要么

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

---

#6楼

我用：

int myint = 0;
long double myLD = 0.0;

string myint_str = static_cast(&(ostringstream() << myint))->str();
string myLD_str = static_cast(&(ostringstream() << myLD))->str();

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

---

#7楼

如果您使用的是MFC ，则可以使用CString ：

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

---

#8楼

您可以使用Matthieu M.建议的 C ++ 11中可用的std::to_string ：

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快10倍以上。 有关更多详细信息，请参见C ++中的快速整数到字符串的转换 。

请注意，两者都是线程安全的。

与std::to_string不同， fmt::format_int不需要C ++ 11，并且可以与任何C ++编译器一起使用。

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

---

#9楼

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

---

#10楼

使用：

#define convertToString(x) #x

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

---

#11楼

您使用算法的计数器类型将其转换为字符串。 我从Commodore 64电脑的编程中获得了这项技术。 这对游戏编程也很有好处。

• 您取整数并取以10的幂进行加权的每个数字，因此假设整数为950。

  • 如果整数等于或大于100,000，则减去100,000，并在[[000000]]处增加字符串中的计数器；
    继续这样做，直到100,000个位置没有更多的数字为止。 降低十的幂。

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

• 掉十的力量

• 重复图案

我知道950太小，无法用作示例，但我希望您能理解。

---

#12楼

已编辑。 如果您需要将固定位数的整数快速转换为用'0'左填充的 char *，这是小端架构（所有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; 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; int64_t s = 0x0000000030303030 | (n/1000)<<56 | (n/100%10)<<48 | (n/10%10)<<40 | (n%10)<<32; 我认为应该可以。

---

#13楼

对于C ++ 98 ，有一些选择：

boost/lexical_cast

Boost不是C ++库的一部分，但是包含许多有用的库扩展。

lexical_cast函数模板提供了一种方便且一致的形式，用于支持在将任意类型表示为文本时与任意类型之间的常见转换。
-Boost的文档

#include "boost/lexical_cast.hpp"
#include 

int main() {
    int x = 5;
    std::string x_str = boost::lexical_cast(x);
    return 0;
}

至于运行时，第一次转换时lexical_cast操作大约需要80微秒（在我的机器上），然后，如果进行了多余的操作，则随后的速度会大大提高。

---

itoa

此函数未在ANSI-C中定义，也不属于C ++，但某些编译器支持。
-cplusplus.com

这意味着gcc / g++无法使用itoa编译代码。

#include 

int main() {
    int x = 5;
    char * x_str = new char[2];
    x_str = itoa(x, x_str, 10); // base 10
    return 0;
}

没有要报告的运行时。 我没有安装Visual Studio， 据说它可以编译itoa 。

---

sprintf

sprintf是可用于C字符串的C标准库函数，并且是完全有效的替代方法。

如果在printf上使用了format，则使用与要打印的文本相同的字符串组成一个字符串，但是内容将作为C字符串存储在由str指向的缓冲区中，而不是被打印。
-cplusplus.com

#include 

int main() {
    int x = 5;
    char * x_str = new char[2];
    int chars_written = sprintf(x_str, "%d", x);
    return 0;
}

stdio.h标头可能不是必需的。 至于运行时，在第一次转换时， sprintf操作大约需要40微秒（在我的机器上），然后，如果进行了多余的操作，则随后的速度会大大提高。

---

stringstream

这是C ++库将整数转换为字符串，反之亦然的主要方法。 有与stringstream类似的姐妹函数，它们进一步限制了流的预期用途，例如ostringstream 。 特别地，使用ostringstream告诉您的代码阅读者，您实质上只打算使用<<操作符。 将整数转换为字符串时，此功能特别重要。 请参阅此问题以进行更详细的讨论。

#include 
#include 

int main() {
    int x = 5;
    std::ostringstream stream;
    stream << x;
    std::string x_str = stream.str();
    return 0;
}

对于运行时， ostringstream操作大约需要71微秒（在我的机器上），然后如果进行冗余处理，则此后速度会大大提高，但不及以前的功能 。

---

当然，还有其他选择，您甚至可以将其中一个包装到自己的函数中，但这可以分析一些流行的选择。

---

#14楼

使用stringstream进行数字转换很危险！

请参阅http://www.cplusplus.com/reference/ostream/ostream/operator%3C%3C/ ，其中它指示operator<<插入格式化的输出。

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

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

因此，我强烈建议您使用std::to_string方法。 它更容易实现您的期望。

更新（请参阅下面的评论） ：

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

---

#15楼

添加一些语法糖相当容易，该语法糖可以使用户以类似流的方式实时编写字符串

#include 
#include 

struct strmake {
    std::stringstream s;
    template  strmake& operator << (const T& x) {
        s << x; return *this;
    }   
    operator std::string() {return s.str();}
};

现在，您可以将所需的任何内容（假设为其定义了运算符<< (std::ostream& ..) ） strmake()到strmake()并使用它代替std::string 。

例：

#include 

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

---

#16楼

这是另一种简单的方法

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

sprintf是众所周知的一种，可以将任何数据插入所需格式的字符串中。

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

---

#17楼

使用：

#include "stdafx.h"
#include
#include
#include

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;

    while (num)
    {
        char toInsert = (num % 10) + 48;
        numAsStr.insert(0, 1, toInsert);

        num /= 10;
    }
    return numAsStr;
}

---

#18楼

C ++ 11为数字类型引入了std::to_string() ：

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

---

#19楼

我认为使用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;
 }

---

#20楼

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

---

#21楼

我不知道，在纯C ++中。 但是对您提到的内容做了一些修改

string s = string(itoa(a));

应该可以，而且很短。

---

#22楼

几年后，通过与@ v.oddou进行讨论，C ++ 17终于提供了一种无需经历宏的丑陋就可以完成最初基于宏的类型不可知的解决方案的方法（下面保留）。

// variadic template
template < 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 ++源代码的中央标头中定义SSTR（）宏：

#include 

#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 ++ 11 std::to_string ），并且不需要任何第三方包含（如果您不能使用Boost lexical_cast<> ）； 这些其他解决方案都具有更好的性能。

---

#23楼

最常见的简单方法大概就是将您的第二选择包装到名为lexical_cast ，例如Boost中的模板，因此您的代码如下所示：

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

这样的好处之一是它也支持其他类型的转换（例如，相反方向的效果也一样）。

还要注意，尽管Boost lexical_cast刚开始只是写到一个字符串流，然后从该流中提取回来，但它现在有几个附加项。 首先，已经添加了许多类型的专门化，因此对于许多常见类型，它比使用stringstream的速度快得多。 其次，它现在检查结果，因此（例如）如果您从字符串转换为int ，并且如果该字符串包含无法转换为int （例如1234将成功，但是123abc会抛出）。

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

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

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

---

#24楼

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

---

#25楼

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

#include 

int num = 4;
std::string str = boost::lexical_cast(num);

---

#26楼

C ++ 11引入了std::stoi （以及每种数字类型的变体）和std::to_string ，它们是C atoi和itoa的对应物，但用std::string 。

#include  

std::string s = std::to_string(42);

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

auto s = std::to_string(42);

注意：请参阅[string.conversions] （ n3242中为 21.5 ）

---

#27楼

这对我有用-

我的代码：

#include 
using namespace std;

int main()
{
    int n = 32;
    string s = to_string(n);
    cout << "string: " + s  << endl;
    return 0;
}