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

时间：2011-04-08 04:19:42

标签： c++ string int type-conversion

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

31 个答案:

答案 0 :(得分：1843)

C ++ 11引入了std::stoi（以及每种数字类型的变体）和std::to_string，C atoi和itoa的对应部分，但以{ {1}}。

std::string
因此，

是我能想到的最短路。您甚至可以使用#include <string> std::string s = std::to_string(42); 关键字省略命名类型：

auto

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

答案 1 :(得分：180)

几年后与@ 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 <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 ++ 11 std::to_string），并且不需要任何第三方包含（如果你不能使用Boost lexical_cast<>）;这些其他解决方案都有更好的表现。

答案 2 :(得分：102)

我通常使用以下方法：

#include <sstream>

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

详细描述here。

答案 3 :(得分：85)

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

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

这方面的一个好处是，它也支持其他演员阵容（例如，在相反的方向上工作也一样）。

另请注意，虽然Boost lexical_cast最初只是写入字符串流，然后从流中提取出来，但它现在有一些补充。首先，添加了很多类型的特化，因此对于许多常见类型，它比使用字符串流要快得多。其次，它现在检查结果，所以（例如）如果从字符串转换为int，如果字符串包含无法转换为int的内容，则会抛出异常（例如，1234会成功，但123abc会抛出。

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

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

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

答案 4 :(得分：41)

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

#include <boost/lexical_cast.hpp>

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

答案 5 :(得分：28)

使用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

或制作一个功能：

#include <sstream>

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

答案 6 :(得分：19)

在纯C ++中，我不知道。但是对你提到的内容进行了一点修改

string s = string(itoa(a));

应该有用，而且很短。

答案 7 :(得分：16)

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

答案 8 :(得分：12)

首先包括：

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

答案 9 :(得分：12)

您可以将C ++ 11中提供的std::to_string用作suggested by 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快10倍以上。有关详细信息，请参阅 Fast integer to string conversion in C++ 。

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

与std::to_string不同，fmt::format_int不需要C ++ 11，也适用于任何C ++编译器。

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

答案 10 :(得分：8)

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

请参阅http://www.cplusplus.com/reference/ostream/ostream/operator%3C%3C/，告知operator<<插入格式化输出。

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

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

所以我强烈建议使用std::to_string方式。它更容易，并且符合您的期望。

答案 11 :(得分：8)

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

boost/lexical_cast

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

  

lexical_cast函数模板提供了一种方便且一致的表单，用于支持在任意类型表示为文本时的常见转换。
   - 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;
}

至于运行时，lexical_cast操作在第一次转换时需要大约80微秒（在我的机器上），然后如果冗余完成则会大大加快。

itoa

  

此函数未在ANSI-C中定义，并且不是C ++的一部分，但受某些编译器支持。
   - cplusplus.com

这意味着gcc / g++无法使用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;
}

没有运行时报告。我没有安装Visual Studio，reportedly能够编译itoa。

sprintf

sprintf是一个C标准库函数，适用于C字符串，是一种非常有效的替代方法。

  

使用与printf上使用的格式相同的文本组成一个字符串，但不是打印，而是将内容作为C字符串存储在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;
}

stdio.h标头可能没有必要。至于运行时，sprintf操作在第一次转换时大约需要40微秒（在我的机器上），然后如果冗余完成则会大大加快。

stringstream

这是C ++库将整数转换为字符串的主要方式，反之亦然。 stringstream有类似的姐妹函数，它们进一步限制了流的预期用途，例如ostringstream。使用ostringstream专门告诉读者您的代码，您只打算使用<<运算符。这个函数是将整数转换为字符串所特有的。有关更详细的讨论，请参阅this question。

#include <sstream>
#include <string>

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

至于运行时，ostringstream操作大约需要71微秒（在我的机器上），然后如果冗余完成则会大大加快，但不像以前的功能那么多

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

答案 12 :(得分：3)

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

答案 13 :(得分：2)

使用：

#define convertToString(x) #x

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

答案 14 :(得分：2)

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

答案 15 :(得分：1)

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

答案 16 :(得分：1)

我用：

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 ++编译器。

答案 17 :(得分：1)

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

答案 18 :(得分：1)

  

这是另一种简单的方法

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

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

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

答案 19 :(得分：1)

使用：

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

答案 20 :(得分：1)

这对我有用-

我的代码：

#include <iostream>
using namespace std;

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

答案 21 :(得分：0)

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

答案 22 :(得分：0)

使用“纯” C ++（没有C ++ 11等）：

#include <bits/stdc++.h>

using namespace std;

string to_str(int x) {
    ostringstream ss;
    ss << x;
    return ss.str();
}

int main()
{
    int number = 10;
    string s = to_str(number);
    cout << s << endl;
    return 0;
}

答案 23 :(得分：0)

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

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

答案 24 :(得分：0)

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

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

记得根据你的需要照顾你的缓冲区大小[字符串输出大小]

答案 25 :(得分：-1)

如果您需要将具有固定位数的整数快速转换为char *左边填充＆＃39; 0＆＃39;，这是一个方便的示例：

int n = 27;
char s[8];

如果您要转换两位数字：

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

以及最多七位数字：）

答案 26 :(得分：-1)

使用CString：

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

答案 27 :(得分：-1)

int n = 123;
std::string str = std::to_string(n);

答案 28 :(得分：-1)

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

答案 29 :(得分：-1)

您可以这样做：

int a = 10;
string str = a + '0';

答案 30 :(得分：-3)

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

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

    • 如果整数等于或大于100,000，则减去100,000并在[＆＃34; 000000＆＃34;]中增加字符串中的计数器;
      继续这样做直到没有更多的数字在100,000位置。 再降10点力量。

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

  • 再次降低十次

  • 重复模式

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

相关问题
最新问题