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


Easiest way to convert int to string in C++

什么是最简单的方法，从EDCOX1的0个方面转换到等效的EDCOX1，1，在C++中。我知道两种方法。有什么更简单的方法吗？

(1)

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

(2)

1
2
3
4
int a = 10;
stringstream ss;
ss << a;
string str = ss.str();
相关讨论

C++ 11介绍了EDCOX1，13，(和每个数值类型的变体)和EDOCX1，0，C eDCOX1，15，EDCX1，16，16，但用EDCOX1，11表示。

1
2
3
#include <string>

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

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

1
auto s = std::to_string(42);

注：见[string.conversions](n3242中的21.5)

相关讨论

几年后，用".v.OdouDo"进行讨论，C++ 17终于提供了一种方法来完成最初的基于宏的类型不可知的解决方案(保存在下面)，而不必经过宏uuyess。

1
2
3
4
5
6
7
8
9
// variadic template
template < typename... Args >
std::string sstr( Args &&... args )
{
    std::ostringstream sstr;
    // fold expression
    ( sstr << std::dec << ... << args );
    return sstr.str();
}

用途：

1
2
3
4
5
6
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 ) );

原始答案：

自从"转换…"String"是一个经常出现的问题，我总是在C++源的一个中心标头中定义String()宏：

1
2
3
4
#include <sstream>

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

使用尽可能简单：

1
2
3
4
5
6
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 EDCOX1×0)，并且不需要任何第三方包含(如果你不能使用Boost EDCOX1 1)，那么这两个解决方案都会有更好的性能。

相关讨论

我通常使用以下方法：

1
2
3
4
5
6
7
8
9
#include <sstream>

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

在这里详细描述。

相关讨论

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

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

其中的一个细节是它也支持其他的铸造(例如，在相反的方向上也同样有效)。

另外请注意，尽管boost lexical_cast开始时只是向stringstream写入内容，然后从流中提取内容，但现在它有了一些附加内容。首先，添加了相当多类型的专门化，因此对于许多常见类型，它实质上比使用Stringstream快。其次，它现在检查结果，因此(例如)如果从字符串转换为int，如果字符串包含无法转换为int的内容(例如，1234将成功，但123abc将失败)，则可以抛出异常。

对于C++ 11，对于整数类型有一个重载的EDCOX1×0函数，因此您可以使用如下代码：

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

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

相关讨论

如果您安装了Boost(您应该这样做)：

1
2
3
4
#include <boost/lexical_cast.hpp>

int num = 4;
std::string str = boost::lexical_cast<std::string>(num);
相关讨论

使用StringStreams不是更容易吗？

1
2
3
4
5
6
7
#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

或者做一个函数：

1
2
3
4
5
6
7
8
#include <sstream>

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

不是我所知道的，在纯C++中。但对你提到的内容稍作修改

1
string s = string(itoa(a));

应该可以，而且很短。

相关讨论

sprintf()对于格式转换非常好。然后，您可以将所得的C字符串分配给C++字符串，如1所示。

相关讨论

首先包括：

1
2
#include <string>
#include <sstream>

第二步添加方法：

1
2
3
4
5
6
7
template <typename T>
string NumberToString(T pNumber)
{
 ostringstream oOStrStream;
 oOStrStream << pNumber;
 return oOStrStream.str();
}

使用如下方法：

1
NumberToString(69);

或

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

如Matthieu M.所建议的，可以使用在C++ 11中可用的EDCOX1〔0〕。

1
std::to_string(42);

或者，如果性能非常关键(例如，如果进行了大量转换)，则可以使用fmt库中的fmt::format_int将整数转换为std::string：

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

或C字符串：

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

后者不做任何动态内存分配，在Boost Karma基准上比std::to_string快10倍以上。请参阅C++中的快速整数到字符串转换的详细信息。

与EDCOX1(0)不同，EDCOX1(22)不需要C++ 11，可以与任何C++编译器一起工作。

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

相关讨论

使用Stringstream进行数字转换是危险的！

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

根据当前的区域设置，大于3位数的整数可以转换为4位数的字符串，并添加额外的千位分隔符。

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

所以我强烈推荐使用std::to_string方式。这很容易，而且可以实现你所期望的。

相关讨论

对于C++ 98，有几个选项：

boost/lexical_cast

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

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

1
2
3
4
5
6
7
8
#include"boost/lexical_cast.hpp"
#include <string>

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

至于运行时，在第一次转换时，lexical_cast操作大约需要80微秒(在我的机器上)，如果冗余地进行转换，那么随后速度会大大加快。

itoa

This function is not defined in ANSI-C and is not part of C++, but is supported by some compilers.
-- cplusplus.com

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

1
2
3
4
5
6
7
8
#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;
}

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

sprintf

sprintf是一个在C字符串上工作的C标准库函数，是一个完全有效的替代方法。

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

1
2
3
4
5
6
7
8
#include <stdio.h>

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专门告诉代码的读者，本质上您只打算使用<<操作符。这个函数是将一个整数转换为一个字符串所特别需要的。有关更详细的讨论，请参阅此问题。

1
2
3
4
5
6
7
8
9
10
#include <sstream>
#include <string>

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

至于运行时，ostringstream操作大约需要71微秒(在我的机器上)，然后如果执行冗余操作，则会大大加快速度，但不会像以前的功能那样快。

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

相关讨论

添加一些语法上的糖分是相当容易的，它允许人们以流式的方式快速地组成字符串。

1
2
3
4
5
6
7
8
9
10
#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();}
};

现在，您可以在strmake()中附加您想要的任何内容(前提是为它定义了一个操作符<< (std::ostream& ..))，并使用它来代替std::string。

例子：

1
2
3
4
5
6
7
#include <iostream>

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

用途：

1
2
3
4
5
6
#define convertToString(x) #x

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

C++ 17提供了STD::To-CARS作为更高性能的与区域无关的替代方案。

1
2
3
4
5
6
7
8
9
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)。

相关讨论

我使用：

1
2
3
4
5
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和Linux g++编译器。

1
2
3
4
5
6
7
8
9
10
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;
}

Here's another easy way to do

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

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
#include"stdafx.h"
#include<iostream>
#include<string>
#include<string.h>


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

我认为，使用Stringstream相当容易。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 string toString(int n)
 {
   stringstream ss(n);
   ss << n;
   return ss.str();
 }

 int main()
 {
    int n;
    cin>>n;
    cout<<toString(n)<<endl;
    return 0;
 }

为什么你不能这么做？

1
2
int a = 10;
string str = a + '0';
相关讨论

1
2
3
4
char * bufSecs = new char[32];
char * bufMs = new char[32];
sprintf(bufSecs,"%d",timeStart.elapsed()/1000);
sprintf(bufMs,"%d",timeStart.elapsed()%1000);
相关讨论

如果需要将固定位数的整数快速转换为char*左加"0"，这是一个方便的示例：

1
2
int n = 27;
char s[8];

如果要转换两位数：

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

如果要转换三位数：

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

如果要转换四位数：

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

等等，最多七位数：)

相关讨论

1
2
int n = 123;
std::string str = std::to_string(n);
相关讨论

使用CString：

1
2
3
int a = 10;
CString strA;
strA.Format("%d", a);
相关讨论

使用计数器类型的算法转换为字符串。我是从64号准将计算机的编程中得到这项技术的。它也有利于游戏编程。

  • 取整数，然后取每一个以10的幂加权的数字。所以假设整数是950。

    • 如果整数等于或大于100000，则减去100000并将字符串中的计数器增加到["000000"]；
      继续这样做，直到100000的位置上没有更多的数字。再投十次

    • 如果整数等于或大于10000，则减去10000并将字符串中的计数器增加到"["000000"]+1"位置；继续这样做，直到10000位不再有数字。

  • 再投十次

  • 重复模式

我知道950太小，不能作为例子，但我希望你能理解这个想法。