你可以使用stringstream的

int str2int (const string &str) {
  stringstream ss(str);
  int num;
  ss >> num;
  return num;
}

如果你有c++ 11，现在合适的解决方案是<string>中的c++整数转换函数:stoi, stol, stoul, stoll, stoull。当给出不正确的输入时，它们会抛出适当的异常，并在底层使用快速和小型的strto*函数。

如果您被c++的早期版本所困扰，那么在实现中模拟这些函数将是向前可移植的。

我认为这三个环节可以概括:

http://tinodidriksen.com/2010/02/07/cpp-convert-int-to-string-speed/ http://tinodidriksen.com/2010/02/16/cpp-convert-string-to-int-speed/ http://www.fastformat.org/performance.html

Stringstream和lexical_cast解决方案与lexical cast使用Stringstream大致相同。

词汇强制转换的一些专门化使用不同的方法，请参阅http://www.boost.org/doc/libs/release/boost/lexical_cast.hpp了解详细信息。整数和浮点数现在专门用于整型到字符串的转换。

可以根据自己的需要专门化lexical_cast，并使其快速运行。这将是让各方满意的最终解决方案，干净而简单。

前面提到的文章展示了转换整数<->字符串的不同方法之间的比较。以下方法是有意义的:旧c-way，精神。Karma, fastformat，简单的循环。

Lexical_cast在某些情况下是可以的，例如int到字符串的转换。

使用词法强制转换将字符串转换为int不是一个好主意，因为它比atoi慢10-40倍，这取决于所使用的平台/编译器。

karma似乎是将整数转换为字符串的最快的库。

ex.: generate(ptr_char, int_, integer_number);

上面文章中提到的基本简单循环是将字符串转换为int的最快方法，显然不是最安全的方法，strtol()似乎是更安全的解决方案

int naive_char_2_int(const char *p) {
    int x = 0;
    bool neg = false;
    if (*p == '-') {
        neg = true;
        ++p;
    }
    while (*p >= '0' && *p <= '9') {
        x = (x*10) + (*p - '0');
        ++p;
    }
    if (neg) {
        x = -x;
    }
    return x;
}

不要做什么

这是我的第一条建议:不要使用stringstream。虽然一开始它看起来使用起来很简单，但您会发现如果想要健壮性和良好的错误处理，就必须做很多额外的工作。

下面是一个直觉上看起来应该有效的方法:

bool str2int (int &i, char const *s)
{
    std::stringstream ss(s);
    ss >> i;
    if (ss.fail()) {
        // not an integer
        return false;
    }
    return true;
}

这有一个主要的问题:str2int(i， "1337h4x0r")将愉快地返回true，我将得到值1337。我们可以通过确保转换后stringstream中不再有字符来解决这个问题:

bool str2int (int &i, char const *s)
{
    char              c;
    std::stringstream ss(s);
    ss >> i;
    if (ss.fail() || ss.get(c)) {
        // not an integer
        return false;
    }
    return true;
}

我们解决了一个问题，但还有其他几个问题。

What if the number in the string is not base 10? We can try to accommodate other bases by setting the stream to the correct mode (e.g. ss << std::hex) before trying the conversion. But this means the caller must know a priori what base the number is -- and how can the caller possibly know that? The caller doesn't know what the number is yet. They don't even know that it is a number! How can they be expected to know what base it is? We could just mandate that all numbers input to our programs must be base 10 and reject hexadecimal or octal input as invalid. But that is not very flexible or robust. There is no simple solution to this problem. You can't simply try the conversion once for each base, because the decimal conversion will always succeed for octal numbers (with a leading zero) and the octal conversion may succeed for some decimal numbers. So now you have to check for a leading zero. But wait! Hexadecimal numbers can start with a leading zero too (0x...). Sigh.

Even if you succeed in dealing with the above problems, there is still another bigger problem: what if the caller needs to distinguish between bad input (e.g. "123foo") and a number that is out of the range of int (e.g. "4000000000" for 32-bit int)? With stringstream, there is no way to make this distinction. We only know whether the conversion succeeded or failed. If it fails, we have no way of knowing why it failed. As you can see, stringstream leaves much to be desired if you want robustness and clear error handling.

这就引出了我的第二条建议:不要为此使用Boost的lexical_cast。考虑一下lexical_cast文档是怎么说的:

哪里的控制程度更高 要求转换， std:: stringstream和 Std::wstringstream提供更多 适当的路径。在哪里 非基于流的转换是 Required, lexical_cast是错误的 工作的工具，而不是 专门针对这种情况。

什么? ?我们已经看到stringstream的控制级别很差，但是它说如果需要“更高级别的控制”，应该使用stringstream而不是lexical_cast。此外，由于lexical_cast只是stringstream的包装器，它也会遇到与stringstream相同的问题:对多个数字基数的支持较差，错误处理较差。

最好的解决方案

幸运的是，有人已经解决了上述所有问题。C标准库包含的strtol和family不存在这些问题。

enum STR2INT_ERROR { SUCCESS, OVERFLOW, UNDERFLOW, INCONVERTIBLE };

STR2INT_ERROR str2int (int &i, char const *s, int base = 0)
{
    char *end;
    long  l;
    errno = 0;
    l = strtol(s, &end, base);
    if ((errno == ERANGE && l == LONG_MAX) || l > INT_MAX) {
        return OVERFLOW;
    }
    if ((errno == ERANGE && l == LONG_MIN) || l < INT_MIN) {
        return UNDERFLOW;
    }
    if (*s == '\0' || *end != '\0') {
        return INCONVERTIBLE;
    }
    i = l;
    return SUCCESS;
}

对于处理所有错误情况并支持从2到36的任何基数的东西来说，这非常简单。如果底数为0(默认值)，它将尝试从任何底数进行转换。或者调用者可以提供第三个参数，并指定只对特定的基数进行转换。它是健壮的，用最少的努力处理所有错误。

喜欢散步(和家庭)的其他原因:

它展示了更好的运行时性能 它引入了更少的编译时开销(其他方法从头文件中引入了近20倍的SLOC) 它的结果是最小的代码大小

绝对没有理由使用其他方法。

传统的C方式仍然有效。我推荐散步或散步。在返回状态和'endPtr'之间，您可以给出良好的诊断输出。它还可以很好地处理多个碱基。

我知道三种将String转换为int的方法:

要么使用stoi(String to int)函数，要么使用Stringstream，第三种方式进行个人转换，代码如下:

1号方法

std::string s1 = "4533";
std::string s2 = "3.010101";
std::string s3 = "31337 with some string";

int myint1 = std::stoi(s1);
int myint2 = std::stoi(s2);
int myint3 = std::stoi(s3);

std::cout <<  s1 <<"=" << myint1 << '\n';
std::cout <<  s2 <<"=" << myint2 << '\n';
std::cout <<  s3 <<"=" << myint3 << '\n';

2方法

#include <string.h>
#include <sstream>
#include <iostream>
#include <cstring>
using namespace std;


int StringToInteger(string NumberAsString)
{
    int NumberAsInteger;
    stringstream ss;
    ss << NumberAsString;
    ss >> NumberAsInteger;
    return NumberAsInteger;
}
int main()
{
    string NumberAsString;
    cin >> NumberAsString;
    cout << StringToInteger(NumberAsString) << endl;
    return 0;
} 

第三种方法-但不是个人转换

std::string str4 = "453";
int i = 0, in=0; // 453 as on
for ( i = 0; i < str4.length(); i++)
{

    in = str4[i];
    cout <<in-48 ;

}