测试字符串以查看是否存在数字并将该值分配给变量，同时跳过所有非数字值？

Question

给定一个字符串“a 19 bcd 20”，我如何测试字符串上的特定位置是否有一个数字？ （不仅仅是字符“1”，而是整个数字“19”和“20”）。

char s[80];
strcpy(s,"a 19 b c d 20");

int i=0;
int num=0;
int digit=0;
for (i =0;i<strlen(s);i++){
    if ((s[i] <= '9') && (s[i] >= '0')){    //how do i test for the whole integer value not just a digit

        //if number then convert to integer
        digit = s[i]-48;
        num = num*10+digit;
    }

    if (s[i] == ' '){
        break; //is this correct here? do nothing
    }
    if (s[i] == 'a'){
       //copy into a temp char
    }
}

Answer 1

这些是 C 解决方案：

您只是想从字符串中解析数字吗？然后您可以使用 strtol() 遍历字符串。

long num = 0;
char *endptr = NULL;
while (*s) {
  num = strtol(s, &endptr, 10);
  if (endptr == s) { // Not a number here, move on.
    s++;
    continue;
  }
  // Found a number and it is in num. Move to next location.
  s = endptr;
  // Do something with num.
}

如果您有具体位置和号码需要检查，您仍然可以执行类似的操作。
例如：“19”在位置 10 吗？

int pos = 10;
int value = 19;
if (pos >= strlen(s))
  return false;
if (value == strtol(s + pos, &endptr, 10) && endptr != s + pos)
  return true;
return false;

您是否尝试在不使用任何库例程的情况下解析这些数字？

注意：我没有测试过这个......

int num=0;
int sign=1;
while (*s) {
  // This could be done with an if, too.
  switch (*s) {
    case '-':
      sign = -1;
    case '+':
      s++;
      if (*s < '0' || *s > '9') {
        sign = 1;
        break;
      }
    case '0':
    case '1':
    case '2':
    case '3':
    case '4':
    case '5':
    case '6':
    case '7':
    case '8':
    case '9':
      // Parse number, start with zero.
      num = 0;
      do {
        num = (num * 10) + (*s - '0');
        s++;
      } while (*s >= '0' && *s <= '9');
      num *= sign;
      // Restore sign, just in case
      sign = 1;
      // Do something with num.
      break;
    default:
      // Not a number
      s++;
  }
}

Answer 2

看起来你想解析字符串并从中提取所有数字；如果是这样，这里有一个更“C++”的方法：

string s = "a 19 b c d 20"; // your char array will work fine here too
istringstream buffer(s);
string token;
int num;
while (!buffer.eof())
{
    buffer >> num; // Try to read a number
    if (!buffer.fail()) {    // if it doesn't work, failbit is set
        cout << num << endl; // It's a number, do what you want here
    } else {
        buffer.clear();  // wasn't a number, clear the failbit
        buffer >> token; // pull out the non-numeric token
    }
}

这应该打印出以下内容：

19 
20

流提取运算符自动提取空格分隔的标记，因此您不必执行任何混乱的字符级操作或手动操作整数转换。您需要为 stringstream 类添加 #include。

Answer 3

您可以使用 atoi()。

Answer 4

在 if 之后，您需要转移到 while 来收集后续数字，直到遇到非数字。

但是，更重要的是，您是否明确定义了您的要求？数字之间允许有空格吗？如果有两个数字（例如 abc123def456gh）怎么办？

Answer 5

它不是很清楚你在寻找什么。假设你想从字符串中提取所有数字，然后从找到的数字中提取整个数字，你可以尝试以下操作：

    int i;
    unsigned long num=0; // to hold the whole number.
    int digit;
    for (i =0;i<s[i];i++){
            // see if the ith char is a digit..if yes extract consecutive digits
            while(isdigit(s[i])) { 
                    num = num * 10 + (s[i] - '0');
                    i++;
            }
    }

假设字符串中的所有数字连接时从整数到整数不会溢出长数据类型。

Answer 6

没有办法测试整数。正如您所做的那样，编写词法分析器是一种方法。另一种方法是尝试使用 C 标准库的 strtoul 函数（或一些类似的函数，具体取决于字符串是否具有浮点数等）。

您的代码需要允许空格，并且您可以使用 C 库的 isdigit 来测试当前字符是否是数字：

vector<int> parse(string const& s) {
     vector<int> vi;
     for (size_t i = 0; i < s.length();) {
         while (::isspace((unsigned char)s[ i ]) i++;
         if (::isdigit((unsigned char)s[ i ])) {
              int num = s[ i ] - '0';
              while (::isdigit((unsigned char)s[ i ])) {
                 num = num * 10 + (s[ i ] - '0');
                 ++i;
              }
              vi.push_back(num);
         }
                ....

另一种方法是使用 boost::lexical_cast >：

 vector<string> tokenize(string const& input) {
     vector<string> tokens;
     size_t off = 0, start = 0;
     while ((off = input.find(' ', start)) != string::npos) {
          tokens.push_back(input.substr(start, off-start));
          start = off + 1;
     }
     return tokens;
 }

 vector<int> getint(vector<string> tokens) {
      vector<int> vi;
      for (vector<string> b = tokens.begin(), e = tokens.end(); b! = e; ++b) {
         try
         {
           tokens.push_back(lexical_cast<short>(*b));
         }
         catch(bad_lexical_cast &) {}
      }
      return vi;
 }