主页 / 问题 / 1390616
Accepted
maestro
Asked:2022-08-16 11:01:31 +0800 CST2022-08-16 11:01:31 +0800 CST

识别非 0 终止字符串中的数字

  • 772

有一个字符串表示为一对迭代器或一个指针char和一个长度。这条线的特殊之处在于它

  • 可能包含一个数字，但只有一个；
  • 可能包含错误值（额外字符或溢出的数字）；
  • 可能什么都没有（begin+1 = end）。

我所知道的 C 和 C++ 标准库函数atoi,需要一个以 null 结尾std::stoi的sscanf字符串。C 和 C++ 库中是否有类似的标准函数？这些功能还需要：

  • 该函数不得在堆上动态分配内存；
  • 该函数不得使用 VLA；
  • 该函数不得抛出异常。

虽然声明 IAR EWARM 8.40.1 支持 C++17，但它不std::string_view包含std::from_chars. 后者看起来是最合适的，尽管它没有写任何地方是否在堆上分配内存以满足内部需求。

c++

3 个回答

  1. Best Answer

    在“复杂”的操作中，需要乘以十，可以用三班一加代替：

    #include <assert.h>
#include <ctype.h>
#include <limits.h>
#include <stdbool.h>

bool parse_uint(int n, const char s[/* n */], unsigned *result) {
    if (n <= 0) {
        return false;
    }
    unsigned r = 0;
    for (const char *p = s; p < s + n; ++p) {
        if (!isdigit((unsigned char)*p)) {
            return false;
        }
        if (r > UINT_MAX / 10u) {
            return false;
        }
        r *= 10u;
        const unsigned d = *p - '0';
        if (r > UINT_MAX - d) {
            return false;
        }
        r += d;
    }
    *result = r;
    return true;
}

int main()
{
    unsigned n;
    assert(parse_uint(1, "0", &n));
    assert(n == 0);
    assert(parse_uint(1, "1", &n));
    assert(n == 1);
    assert(parse_uint(2, "10", &n));
    assert(n == 10);
    assert(parse_uint(10, "4294967295", &n));
    assert(n == 4294967295);
    assert(!parse_uint(10, "4294967296", &n));
    assert(!parse_uint(11, "42949672950", &n));
    assert(!parse_uint(3, "1_2", &n));
    assert(!parse_uint(0, "0", &n));
    return 0;
}
    • 3

  2. ⚠️ 显然，这个解决方案假设在没有 UB 的情况下可读的区域中仍然存在终止 0，但不一定紧跟在子字符串的结尾之后。

    答案的评论中有更多详细信息。

    sscanf可以做任何事情（顺便说一下，我没有检查 int 溢出）：操场

    #include <cstdio>
#include <iostream>

using namespace std;

void f(const char *s, const char *e)
{
  int n = e-s-1;

  if (n >= 0)
    printf("'%.*s' (len %d) - ", n, s, n);
  else
    printf("(len %d) - ", n);

  if (n < 0)
    puts("invalid arguments");
  else if (!n)
    puts("empty input");
  else
  {
    char format[32];
    sprintf(format, "%%%dd%%n", n);
    int x, m;
    sscanf(s, format, &x, &(m=0));

    if (n != m)
      puts("invalid input");
    else
      printf("parsed as %d\n", x);
  }
}

int main()
{
  const char *s = "-12345-67890123456789";

  f(s, s);

  f(s, s+1);
  f(s, s+2);
  f(s, s+7);
  f(s, s+8);
  f(s, s+10);

  f(s+1, s+2);
  f(s+1, s+3);
  f(s+1, s+7);
  f(s+1, s+8);
  f(s+1, s+10);

  f(s+6, s+17);
  f(s+6, s+18);
  f(s+7, s+17);
  f(s+7, s+18);

  f(s+18, s+20);
  f(s+18, s+21);
  f(s+18, s+22);
  f(s+18, s+23);
  f(s+18, s+100000);
}

    (len -1) - invalid arguments
'' (len 0) - empty input
'-' (len 1) - invalid input
'-12345' (len 6) - parsed as -12345
'-12345-' (len 7) - invalid input
'-12345-67' (len 9) - invalid input
'' (len 0) - empty input
'1' (len 1) - parsed as 1
'12345' (len 5) - parsed as 12345
'12345-' (len 6) - invalid input
'12345-67' (len 8) - invalid input
'-678901234' (len 10) - parsed as -678901234
'-6789012345' (len 11) - parsed as 1800922247
'678901234' (len 9) - parsed as 678901234
'6789012345' (len 10) - parsed as -1800922247
'7' (len 1) - parsed as 7
'78' (len 2) - parsed as 78
'789' (len 3) - parsed as 789
'789' (len 4) - invalid input
'789' (len 99981) - invalid input
    • 0

  3. 这是我对此类功能的实现。

    namespace Internal {
    inline uint32_t MultiplyAccumulate(uint32_t m1, uint32_t m2, uint32_t add, bool &overflow)
    {
        uint32_t ovf = 0;
        //В инструкции MUL набора инструкций thumb-2 поведение флага C не определено. Поскольку работаем с 
        //беззнаковыми числами, а слишком больших чисел не ожидается, можно заменить проверку переполнения флагом N.
        //После операции сложения проверяются флаги S и V. 
        asm volatile ("B calc \n"
                        "ovf: mov %6, #1 \n"
                        "B fin \n"
                        "calc: \n"
                        "muls %0, %1, %2 \n"
                        "BMI ovf \n"
                        "adds %3, %4, %5 \n"
                        "BVS ovf \n"
                        "BCS ovf \n"
                        "fin:"
                            :: "r"(m1), "r"(m1), "r"(m2), 
                                "r"(m1), "r"(m1), "r"(add),
                                "r"(ovf));
        overflow = (bool)ovf;
        return m1;
    }
};

/// \brief Преобразование массива символов в число
/// \details Функция принимает массив в виде пары итераторов и
/// выполняет преобразование его в число. 
/// \param begin Итератор начала массива
/// \param end Итератор конца массива
template<typename Iterator>
std::experimental::optional<uint32_t> ParseUint32(const Iterator begin, const Iterator end)
{
    using value_type = typename std::iterator_traits<Iterator>::value_type;
    auto rbegin = std::make_reverse_iterator(end);
    auto rend = std::make_reverse_iterator(begin);
    
    uint32_t result = 0;
    int radix = 1;
    bool overflow = 0;
    for (auto it = rbegin; it != rend; it++, radix *= 10)
    {
        if (*it < '0' || *it > '9')
            return std::experimental::nullopt;
        uint32_t val = *it - '0';
        result = Internal::MultiplyAccumulate(val, radix, result, overflow);
        if (overflow)
        {
            return std::experimental::nullopt;
        }
    }
    return result;
}

    其他类型可以类似地实现。

    • -1

相关问题