c - 输入为字符串，输出为 int 例如输入是 1 输出应该是 1

Question

我尝试过 atoi() 函数和 strtol() 函数，但没有得到所需的输出。如何将字符串转换为数值，例如输入是 1000，输出应该是 1000。谢谢

    #include<stdio.h>
#include<stdlib.h>



int main ()
{
    int i;
    char buffer [256];

    printf ("Enter a number: ");
    fgets (buffer, 256, stdin);

    i = atoi (buffer);
    printf ("The value entered is %d.",i);

    return 0;
}

Answer 1

解析自然语言中的数字并非易事。您可以通过字符串匹配来检测小数字，并且通过拆分“二十三”之类的数字很容易解析它们，但通用方法很困难。例如“三十万”中的“百”指的是十万，而不是一百。

没有用于此目的的库函数，因为数字更好且更普遍地表示为十进制数字。此外，这样的函数只能在一种语言中运行。

但你可以自己推出。下面的代码将单词分成值 block (例如四、二十三)和乘数 block (例如千)。两者都是可选的。它保留了一堆这样的值乘数对来跟踪“优先级”:“十万四千”意味着(1 * 100 + 4) * 1000，但是“一千一百和四”表示1 * 1000 + 1 * 100 + 4。当第一个乘数小于以下值时，首先对其求值。

代码区分大小写，但它可以处理字符串文字。下面的 main 函数中有一个小型测试套件。

#include <stdlib.h>
#include <stdio.h>
#include <stdint.h>
#include <inttypes.h>



static const char *next(const char **p, int *len)
{
    const char *t = NULL;

    while (**p == ' ' || **p == '-') (*p)++;
    if (**p == '\0') return NULL;

    t = *p;
    while (**p && **p != ' ' && **p != '-') (*p)++;
    if (len) *len = *p - t;

    return t;
}

static int eq(const char *q, const char *p, int len)
{
    if (p == NULL) return 0;

    while (len--) {
        if (*p != *q) return 0;
        if (*p == '\0' || *q == '\0') return 0;
        p++; q++;
    }

    return (*q == '\0');
}

static int in(const char **q, const char *p, int len)
{
    int ix = 0;

    if (p == NULL) return 0;

    while (*q) {
        if (eq(*q, p, len)) return ix;
        ix++;
        q++;
    }

    return -1;
}

#define MAX 32

int parse_num(const char *p, int64_t *n)
{
    static const char *ones[] = {
        "zero", "one", "two", "three", "four", "five", "six",
        "seven", "eight", "nine", "ten", "eleven", "twelve",
        "thirteen", "fourteen", "fifteen", "sixteen",
        "seventeen", "eighteen", "nineteen", NULL
    };

    static const char *tens[] = {
        "-", "-", "twenty", "thirty", "forty", "fifty",
        "sixty", "seventy", "eighty", "ninety", NULL
    };

    int64_t value[MAX];
    int64_t base[MAX];
    int nvalue = 0;

    const char *t;
    int neg = 0;
    int len;
    int x;

    *n = 0;

    t = next(&p, &len);
    if (eq("minus", t, len)) {
        neg = 1;
        t = next(&p, &len);
    }

    while (t) {
        int64_t num = 0;
        int64_t mult = 1;
        int valid = 0;

        if (nvalue && eq("and", t, len)) t = next(&p, &len);

        x = in(tens, t, len);
        if (x >= 0) {
            num += x * 10;
            t = next(&p, &len);
            valid = 1;
        }

        x = in(ones, t, len);
        if (x >= 0) {
            num += x;
            t = next(&p, &len);
            valid = 1;
        }

        if (valid == 0) {
            long int l;
            char *end;

            l = strtol(t, &end, 10);
            if (end == p) {                
                num = l;
                valid = 1;
                t = next(&p, &len);
            }
        }

        if (eq("quadrillion", t, len))  mult = 1000000000000000LL;
        if (eq("trillion", t, len))     mult = 1000000000000LL;
        if (eq("billion", t, len))      mult = 1000000000LL;
        if (eq("million", t, len))      mult = 1000000LL;
        if (eq("thousand", t, len))     mult = 1000LL;
        if (eq("hundred", t, len))      mult = 100LL;

        if (mult > 1) {
            valid = 1;
            t = next(&p, &len);
        }

        if (valid == 0) return 0;        

        if (nvalue && base[nvalue - 1] == mult) return 0;

        while (nvalue && base[nvalue - 1] < mult) {
            nvalue--;
            num += value[nvalue] * base[nvalue];
        }

        if (nvalue == MAX) return 0;
        if (mult > 1 && num == 0) num = 1;

        value[nvalue] = num;
        base[nvalue] = mult;
        nvalue++;
    }

    if (t != NULL) return 0;
    if (nvalue == 0) return 0;

    while (nvalue--) {
        *n += value[nvalue] * base[nvalue];
    }
    if (neg) *n = -*n;

    return 1;
}

int main()
{
    const char *str[] = {
        "zero",
        "three",
        "minus one",
        "ten",
        "twenty-one",
        "eighty",
        "eight hundred eighty-eight",
        "three hundred and nineteen",
        "eleven hundred",
        "one hundred and twenty one",
        "twenty-four thousand",
        "thirty thousand one",
        "two million",
        "two hundred thirty thousand and eleven",
        "three million two hundred and thirty thousand and eleven",
        "minus eight trillion",
        "fifty-five billion one million nine thousand and twelve",
        "one thousand million",
        "nine hundred thousand",
        "nine thousand hundred",
        "one hundred thousand million",
        "nineteen hundred eighty-four",
        "4 billion 294 million 967 thousand 296",
        "two thousand thousand",
        "minus",
        "thirty-something",
        NULL
    };
    const char **p = str;

    while (*p) {
        int64_t n;
        int res;

        res = parse_num(*p, &n);
        if (res) {
            printf("%18" PRId64, n);
        } else {
            printf("%18s", "---");
        }
        printf("  %s\n", *p);
        p++;
    }

    return 0;
}