我想将一个字符串转换为int,我不是指ASCII码。

为了快速回顾,我们将一个方程作为字符串传递。我们要把它分解,正确地格式化并解出线性方程。说到这里,我不能把一个字符串转换成int型。

我知道字符串的格式是(-5)或(25)等,所以它肯定是int型。但是我们如何从字符串中提取它呢?

我想到的一种方法是在字符串中运行一个for/while循环,检查一个数字,提取后面的所有数字,然后看看是否有前导'-',如果有,将int乘以-1。

对于这样一个小问题来说,这似乎有点过于复杂了。什么好主意吗?


使用atoi函数将字符串转换为整数:

string a = "25";

int b = atoi(a.c_str());

http://www.cplusplus.com/reference/clibrary/cstdlib/atoi/


std::istringstream ss(thestring);
ss >> thevalue;

为了完全正确,您需要检查错误标志。


Atoi是一个内置函数,它将字符串转换为整数,假设字符串以整数表示形式开始。

http://www.cplusplus.com/reference/clibrary/cstdlib/atoi/


诚然,我的解决方案不适用于负整数,但它将从包含整数的输入文本中提取所有正整数。它使用numeric_only locale:

int main() {
        int num;
        std::cin.imbue(std::locale(std::locale(), new numeric_only()));
        while ( std::cin >> num)
             std::cout << num << std::endl;
        return 0;
}

输入文本:

 the format (-5) or (25) etc... some text.. and then.. 7987...78hjh.hhjg9878

输出整数:

 5
25
7987
78
9878

类numeric_only定义为:

struct numeric_only: std::ctype<char> 
{
    numeric_only(): std::ctype<char>(get_table()) {}

    static std::ctype_base::mask const* get_table()
    {
        static std::vector<std::ctype_base::mask> 
            rc(std::ctype<char>::table_size,std::ctype_base::space);

        std::fill(&rc['0'], &rc[':'], std::ctype_base::digit);
        return &rc[0];
    }
};

完整在线演示:http://ideone.com/dRWSj


Boost.Lexical_cast呢?

下面是他们的例子:

下面的例子将命令行参数视为数值数据序列:

int main(int argc, char * argv[])
{
    using boost::lexical_cast;
    using boost::bad_lexical_cast;

    std::vector<short> args;

    while(*++argv)
    {
        try
        {
            args.push_back(lexical_cast<short>(*argv));
        }
        catch(bad_lexical_cast &)
        {
            args.push_back(0);
        }
    }
    ...
}

可能有点过分了,但是 boost::lexical_cast<int>(theString)应该是作业 很好。


在c++ 11中,有一些不错的新转换函数,从std::string转换为数字类型。

所以与其

atoi( str.c_str() )

你可以使用

std::stoi( str )

其中STR是你的数字std::string。

各种类型的数字都有对应的版本: 长stol(字符串),浮动stof(字符串),双stof(字符串),… 参见http://en.cppreference.com/w/cpp/string/basic_string/stol


还有另一种简单的方法:假设你有一个像c='4'这样的字符,那么你可以执行以下步骤之一:

第一个:int q

Q =(int) c;(q现在在ASCII表中是52)。 q = q-48;记住,数字加48是他们的ASCII码。

第二种方式:

q = c - ' 0 ';同样,字符“0”表示48


可能的选择如下:

1. sscanf ()

    #include <cstdio>
    #include <string>

        int i;
        float f;
        double d;
        std::string str;

        // string -> integer
        if(sscanf(str.c_str(), "%d", &i) != 1)
            // error management

        // string -> float
        if(sscanf(str.c_str(), "%f", &f) != 1)
            // error management
    
        // string -> double 
        if(sscanf(str.c_str(), "%lf", &d) != 1)
            // error management

这是一个错误(cppcheck也显示了),因为“在libc的某些版本上,没有字段宽度限制的scanf会因大量输入数据而崩溃”(参见这里和这里)。

2. std::我()*

    #include <iostream>
    #include <string>

        int i;
        float f;
        double d;
        std::string str;

        try {
            // string -> integer
            int i = std::stoi(str);

            // string -> float
            float f = std::stof(str);

            // string -> double 
            double d = std::stod(str);
        } catch (...) {
            // error management
        }   

这个解决方案短小精悍,但只能在c++ 11兼容的编译器上使用。

3. sstreams

    #include <string>
    #include <sstream>

        int i;
        float f;
        double d;
        std::string str;

        // string -> integer
        std::istringstream ( str ) >> i;

        // string -> float
        std::istringstream ( str ) >> f;

        // string -> double 
        std::istringstream ( str ) >> d;

        // error management ??

然而,使用这种解决方案很难区分错误的输入(参见这里)。

4. 提高的lexical_cast

    #include <boost/lexical_cast.hpp>
    #include <string>

        std::string str;

        try {
            int i = boost::lexical_cast<int>( str.c_str());
            float f = boost::lexical_cast<int>( str.c_str());
            double d = boost::lexical_cast<int>( str.c_str());
            } catch( boost::bad_lexical_cast const& ) {
                // Error management
        }

但是,这只是sstream的包装器,文档建议使用sstream来更好地管理错误(请参阅这里)。

5. strto () *

由于错误管理,这个解决方案很长,这里将对其进行描述。由于没有函数返回纯int,因此需要对整数进行转换(参见这里了解如何实现这种转换)。

6. Qt

    #include <QString>
    #include <string>

        bool ok;
        std::string;

        int i = QString::fromStdString(str).toInt(&ok);
        if (!ok)
            // Error management
    
        float f = QString::fromStdString(str).toFloat(&ok);
        if (!ok)
            // Error management 

        double d = QString::fromStdString(str).toDouble(&ok);
        if (!ok)
    // Error management     
    

结论

综上所述,最好的解决方案是c++ 11 std::stoi(),或者作为第二种选择,使用Qt库。所有其他的解决方案都是不鼓励的或有缺陷的。


在Windows中,你可以使用:

const std::wstring hex = L"0x13";
const std::wstring dec = L"19";

int ret;
if (StrToIntEx(hex.c_str(), STIF_SUPPORT_HEX, &ret)) {
    std::cout << ret << "\n";
}
if (StrToIntEx(dec.c_str(), STIF_SUPPORT_HEX, &ret)) {
    std::cout << ret << "\n";
}

如果需要解释十六进制,Strtol和stringstream需要指定基数。


有很多答案,很多可能性。我在这里缺少的是一些通用方法,可以将字符串转换为不同的c++整型(short, int, long, bool,…) 我想出了以下解决方案:

#include<sstream>
#include<exception>
#include<string>
#include<type_traits>

using namespace std;

template<typename T>
T toIntegralType(const string &str) {
    static_assert(is_integral<T>::value, "Integral type required.");
    T ret;
    stringstream ss(str);
    ss >> ret;
    if ( to_string(ret) != str)
        throw invalid_argument("Can't convert " + str);
    return ret;
}

下面是用法示例:

string str = "123";
int x = toIntegralType<int>(str); // x = 123

str = "123a";
x = toIntegralType<int>(str); // throws exception, because "123a" is not int

str = "1";
bool y = toIntegralType<bool>(str); // y is true
str = "0";
y = toIntegralType<bool>(str); // y is false
str = "00";
y = toIntegralType<bool>(str); // throws exception

为什么不直接使用stringstream输出操作符将字符串转换为整型? 以下是答案: 假设字符串包含的值超出了预期整型的限制。例如,在windows 64上,max int是2147483647。 让我们给一个字符串赋值max int + 1: string str = "2147483648"。 现在,当将字符串转换为int类型时:

stringstream ss(str);
int x;
ss >> x;

X变成2147483647,这肯定是一个错误:字符串“2147483648”不应该被转换为int 2147483647。为integraltype提供的函数会发现这样的错误并抛出异常。


一行版本:long n = strtol(s.c c_str(), NULL, base);.

(s为字符串,base为int,如2,8,10,16)

你可以参考这个链接了解更多关于strtol的细节。


核心思想是使用sttol函数,该函数包含在cstdlib中。

由于strtol只处理char数组,我们需要将字符串转换为char数组。你可以参考这个链接。

一个例子:

#include <iostream>
#include <string>   // string type
#include <bitset>   // bitset type used in the output

int main(){
    s = "1111000001011010";
    long t = strtol(s.c_str(), NULL, 2); // 2 is the base which parse the string

    cout << s << endl;
    cout << t << endl;
    cout << hex << t << endl;
    cout << bitset<16> (t) << endl;

    return 0;
}

它将输出:

1111000001011010
61530
f05a
1111000001011010

从http://www.cplusplus.com/reference/string/stoi/

// stoi example
#include <iostream>   // std::cout
#include <string>     // std::string, std::stoi

int main ()
{
  std::string str_dec = "2001, A Space Odyssey";
  std::string str_hex = "40c3";
  std::string str_bin = "-10010110001";
  std::string str_auto = "0x7f";

  std::string::size_type sz;   // alias of size_t

  int i_dec = std::stoi (str_dec,&sz);
  int i_hex = std::stoi (str_hex,nullptr,16);
  int i_bin = std::stoi (str_bin,nullptr,2);
  int i_auto = std::stoi (str_auto,nullptr,0);

  std::cout << str_dec << ": " << i_dec << " and [" << str_dec.substr(sz) << "]\n";
  std::cout << str_hex << ": " << i_hex << '\n';
  std::cout << str_bin << ": " << i_bin << '\n';
  std::cout << str_auto << ": " << i_auto << '\n';

  return 0;
}

输出:

2001,太空漫游:2001和[,太空漫游]

40 c3: 16579

-10010110001: -1201

0x7f:127


我的代码:

#include <iostream>
using namespace std;

int main()
{
    string s="32";  //String
    int n=stoi(s);  //Convert to int
    cout << n + 1 << endl;

    return 0;
}

ll toll(string a){
    ll ret=0;
    bool minus=false;
    for(auto i:a){
        if(i=='-'){ minus=true; continue; }
        ret*=10;
        ret+=(i-'0');
    } if(minus) ret*=-1;
    return ret;
    # ll is defined as, #define ll long long int
    # usage: ll a = toll(string("-1234"));
}

要将字符串表示形式转换为整数值,可以使用std::stringstream。

如果转换的值超出整数数据类型的范围,则返回INT_MIN或INT_MAX。

此外,如果字符串值不能表示为有效的int数据类型,则返回0。

#include 
#include 
#include 

int main() {

    std::string x = "50";
    int y;
    std::istringstream(x) >> y;
    std::cout << y << '\n';
    return 0;
}

输出: 50

根据上面的输出,我们可以看到它从字符串数转换为整数数。

来源和更多的字符串int c++


1. std:: stoi

std::string str = "10";  
int number = std::stoi(str); 

2. 字符串流

std::string str = "10";  
int number;  
std::istringstream(str) >> number

3.boost:: lexical_cast

#include <boost/lexical_cast.hpp>
std::string str = "10";  
int number;
    
try 
{
    number = boost::lexical_cast<int>(str);
    std::cout << number << std::endl;
}
catch (boost::bad_lexical_cast const &e) // bad input
{
    std::cout << "error" << std::endl;
}

4. std:: atoi

std::string str = "10";
int number = std::atoi(str.c_str()); 

5. sscanf ()

 std::string str = "10";
 int number;
 if (sscanf(str .c_str(), "%d", &number) == 1) 
 {
     std::cout << number << '\n';
 } 
 else 
 {
     std::cout << "Bad Input";
 }

我知道这个问题很老了,但我认为有更好的解决方法

#include <string>
#include <sstream>

bool string_to_int(std::string value, int * result) {
  std::stringstream stream1, stream2;
  std::string stringednumber;
  int tempnumber;
  stream1 << value;
  stream1 >> tempnumber;
  stream2 << tempnumber;
  stream2 >> stringednumber;
  if (!value.compare(stringednumber)) {
    *result = tempnumber;
    return true;
  }
  else return false;
}

如果我写的代码是正确的,这将返回一个布尔值,告诉你如果字符串是一个有效的数字,如果为假,它不是一个数字,如果为真,它是一个数字,这个数字现在是结果,你会这样调用它:

std::string input;
std::cin >> input;
bool worked = string_to_int(input, &result);

为了更详尽(正如评论中要求的那样),我使用std::from_chars添加了c++ 17给出的解决方案。

std::string str = "10";
int number;
std::from_chars(str.data(), str.data()+str.size(), number);

如果您想检查转换是否成功:

std::string str = "10";
int number;
auto [ptr, ec] = std::from_chars(str.data(), str.data()+str.size(), number);
assert(ec == std::errc{});
// ptr points to chars after read number

此外,要比较所有这些解决方案的性能,请参阅以下快速工作台链接:https://quick-bench.com/q/GBzK53Gc-YSWpEA9XskSZLU963Y

(std::from_chars是最快的std::istringstream是最慢的)


如果你不懂硬代码:)

bool strCanBeInt(std::string string){
    for (char n : string) {
        if (n != '0' && n != '1' && n != '2' && n != '3' && n != '4' && n != '5'
            && n != '6' && n != '7' && n != '8' && n != '9') {
            return false;
        }
    }
    return true;
}

int strToInt(std::string string) {
    int integer = 0;
    int numInt;
    for (char n : string) {
        if(n == '0') numInt = 0;
        if(n == '1') numInt = 1;
        if(n == '2') numInt = 2;
        if(n == '3') numInt = 3;
        if(n == '4') numInt = 4;
        if(n == '5') numInt = 5;
        if(n == '6') numInt = 6;
        if(n == '7') numInt = 7;
        if(n == '8') numInt = 8;
        if(n == '9') numInt = 9;
        if (integer){
            integer *= 10;
        }
        integer += numInt;
    }
    return integer;
}

 int stringToInt(std::string value) {    
 if(value.length() == 0 ) return 0; //tu zmiana..

 if (value.find(  std::string("NULL") ) != std::string::npos) {
     return 0;
  }
 
  if (value.find(  std::string("null") ) != std::string::npos) {
     return 0;
  }
 
 
int i;
std::stringstream stream1;
stream1.clear();
stream1.str(value);
stream1 >> i;
return i;

};


我认为从int转换为std::string或反之亦然需要一些特殊的函数,如std::stoi() 但是如果你需要将double类型转换为字符串,请使用to_string()(不是c#。c#是.ToString()而不是to_string()


你可以使用std::stringstream,这里有一个例子:

#include <iostream>
#include <sstream>
using namespace std;
string r;
int main() {
    cin >> r;
    stringstream tmp(r);
    int s;
    tmp >> s;
    cout << s;
    return 0;
}

在c++ 11中,我们可以使用"stoi"函数将字符串转换为int型

#include <iostream>
#include <string>
using namespace std;
 
int main()
{
    string s1 = "16";
    string s2 = "9.49";
    string s3 = "1226";
 
    int num1 = stoi(s1);
    int num2 = stoi(s2);
    int num3 = stoi(s3);
 
    cout << "stoi(\"" << s1 << "\") is " << num1 << '\n';
    cout << "stoi(\"" << s2 << "\") is " << num2 << '\n';
    cout << "stoi(\"" << s3 << "\") is " << num3 << '\n';
 
    return 0;
}