วิธีการแปลงสตริงเป็นจำนวนเต็มใน C?

ฉันพยายามค้นหาว่ามีวิธีอื่นในการแปลงสตริงเป็นจำนวนเต็มใน C หรือไม่

ฉันทำรูปแบบต่อไปนี้เป็นประจำในรหัสของฉัน

char s[] = "45";

int num = atoi(s);

ดังนั้นจะมีวิธีที่ดีกว่าหรืออีกวิธีหนึ่งหรือไม่

นอกจากนี้strtolที่ดี IMO นอกจากนี้ฉันยังชอบที่strtonumจะใช้ดังนั้นถ้าคุณมีมัน (แต่จำไว้ว่ามันไม่ได้พกพา):

long long
     strtonum(const char *nptr, long long minval, long long maxval,
     const char **errstr);

แก้ไข

คุณอาจสนใจstrtoumaxและstrtoimaxเป็นฟังก์ชันมาตรฐานใน C99 ตัวอย่างเช่นคุณสามารถพูดได้:

uintmax_t num = strtoumax(s, NULL, 10);
if (num == UINTMAX_MAX && errno == ERANGE)
    /* Could not convert. */

อย่างไรก็ตามอยู่ห่างจากatoi:

การเรียก atoi (str) จะเทียบเท่ากับ:

(int) strtol(str, (char **)NULL, 10)

ยกเว้นว่าการจัดการข้อผิดพลาดอาจแตกต่างกัน ถ้าค่าไม่สามารถแสดงพฤติกรรมจะไม่ได้กำหนด

strtolโซลูชันพื้นฐานที่แข็งแกร่ง C89

ด้วย:

• ไม่มีพฤติกรรมที่ไม่ได้กำหนด (อย่างที่ควรมีกับatoiครอบครัว)
• คำจำกัดความที่เข้มงวดของจำนวนเต็มกว่าstrtol(เช่นไม่มีช่องว่างนำหน้าหรือถังขยะต่อท้าย)
• การจำแนกประเภทของกรณีข้อผิดพลาด (เช่นให้ข้อความแสดงข้อผิดพลาดที่เป็นประโยชน์แก่ผู้ใช้
• "testuite"

#include <assert.h>
#include <ctype.h>
#include <errno.h>
#include <limits.h>
#include <stdio.h>
#include <stdlib.h>

typedef enum {
    STR2INT_SUCCESS,
    STR2INT_OVERFLOW,
    STR2INT_UNDERFLOW,
    STR2INT_INCONVERTIBLE
} str2int_errno;

/* Convert string s to int out.
 *
 * @param[out] out The converted int. Cannot be NULL.
 *
 * @param[in] s Input string to be converted.
 *
 *     The format is the same as strtol,
 *     except that the following are inconvertible:
 *
 *     - empty string
 *     - leading whitespace
 *     - any trailing characters that are not part of the number
 *
 *     Cannot be NULL.
 *
 * @param[in] base Base to interpret string in. Same range as strtol (2 to 36).
 *
 * @return Indicates if the operation succeeded, or why it failed.
 */
str2int_errno str2int(int *out, char *s, int base) {
    char *end;
    if (s[0] == '\0' || isspace(s[0]))
        return STR2INT_INCONVERTIBLE;
    errno = 0;
    long l = strtol(s, &end, base);
    /* Both checks are needed because INT_MAX == LONG_MAX is possible. */
    if (l > INT_MAX || (errno == ERANGE && l == LONG_MAX))
        return STR2INT_OVERFLOW;
    if (l < INT_MIN || (errno == ERANGE && l == LONG_MIN))
        return STR2INT_UNDERFLOW;
    if (*end != '\0')
        return STR2INT_INCONVERTIBLE;
    *out = l;
    return STR2INT_SUCCESS;
}

int main(void) {
    int i;
    /* Lazy to calculate this size properly. */
    char s[256];

    /* Simple case. */
    assert(str2int(&i, "11", 10) == STR2INT_SUCCESS);
    assert(i == 11);

    /* Negative number . */
    assert(str2int(&i, "-11", 10) == STR2INT_SUCCESS);
    assert(i == -11);

    /* Different base. */
    assert(str2int(&i, "11", 16) == STR2INT_SUCCESS);
    assert(i == 17);

    /* 0 */
    assert(str2int(&i, "0", 10) == STR2INT_SUCCESS);
    assert(i == 0);

    /* INT_MAX. */
    sprintf(s, "%d", INT_MAX);
    assert(str2int(&i, s, 10) == STR2INT_SUCCESS);
    assert(i == INT_MAX);

    /* INT_MIN. */
    sprintf(s, "%d", INT_MIN);
    assert(str2int(&i, s, 10) == STR2INT_SUCCESS);
    assert(i == INT_MIN);

    /* Leading and trailing space. */
    assert(str2int(&i, " 1", 10) == STR2INT_INCONVERTIBLE);
    assert(str2int(&i, "1 ", 10) == STR2INT_INCONVERTIBLE);

    /* Trash characters. */
    assert(str2int(&i, "a10", 10) == STR2INT_INCONVERTIBLE);
    assert(str2int(&i, "10a", 10) == STR2INT_INCONVERTIBLE);

    /* int overflow.
     *
     * `if` needed to avoid undefined behaviour
     * on `INT_MAX + 1` if INT_MAX == LONG_MAX.
     */
    if (INT_MAX < LONG_MAX) {
        sprintf(s, "%ld", (long int)INT_MAX + 1L);
        assert(str2int(&i, s, 10) == STR2INT_OVERFLOW);
    }

    /* int underflow */
    if (LONG_MIN < INT_MIN) {
        sprintf(s, "%ld", (long int)INT_MIN - 1L);
        assert(str2int(&i, s, 10) == STR2INT_UNDERFLOW);
    }

    /* long overflow */
    sprintf(s, "%ld0", LONG_MAX);
    assert(str2int(&i, s, 10) == STR2INT_OVERFLOW);

    /* long underflow */
    sprintf(s, "%ld0", LONG_MIN);
    assert(str2int(&i, s, 10) == STR2INT_UNDERFLOW);

    return EXIT_SUCCESS;
}

GitHub ต้นน้ำ

อ้างอิงจาก: https://stackoverflow.com/a/6154614/895245

อย่าใช้ฟังก์ชั่นจากato...กลุ่ม สิ่งเหล่านี้แตกและไร้ประโยชน์อย่างแท้จริง ทางออกที่ดีกว่าในระดับปานกลางคือการใช้งานsscanfแม้ว่ามันจะไม่สมบูรณ์ก็ตาม

ในการแปลงสตริงเป็นจำนวนเต็มstrto...ควรใช้ฟังก์ชันจากกลุ่ม ในกรณีเฉพาะของคุณมันจะเป็นstrtolฟังก์ชั่น

คุณสามารถเขียนโค้ด atoi () เพื่อความสนุกสนาน:

int my_getnbr(char *str)
{
  int result;
  int puiss;

  result = 0;
  puiss = 1;
  while (('-' == (*str)) || ((*str) == '+'))
  {
      if (*str == '-')
        puiss = puiss * -1;
      str++;
  }
  while ((*str >= '0') && (*str <= '9'))
  {
      result = (result * 10) + ((*str) - '0');
      str++;
  }
  return (result * puiss);
}

นอกจากนี้คุณยังสามารถทำให้มันซ้ำซึ่งสามารถเก่าใน 3 บรรทัด =)

เพียงแค่ต้องการแบ่งปันวิธีแก้ปัญหาสำหรับผู้ที่ไม่ได้ลงนามและ

unsigned long ToUInt(char* str)
{
    unsigned long mult = 1;
    unsigned long re = 0;
    int len = strlen(str);
    for(int i = len -1 ; i >= 0 ; i--)
    {
        re = re + ((int)str[i] -48)*mult;
        mult = mult*10;
    }
    return re;
}

int atoi(const char* str){
    int num = 0;
    int i = 0;
    bool isNegetive = false;
    if(str[i] == '-'){
        isNegetive = true;
        i++;
    }
    while (str[i] && (str[i] >= '0' && str[i] <= '9')){
        num = num * 10 + (str[i] - '0');
        i++;
    }
    if(isNegetive) num = -1 * num;
    return num;
}

คุณสามารถม้วนของคุณเอง!

#include <stdio.h>
#include <string.h>
#include <math.h>

int my_atoi(const char* snum)
{
    int idx, strIdx = 0, accum = 0, numIsNeg = 0;
    const unsigned int NUMLEN = (int)strlen(snum);

    /* Check if negative number and flag it. */
    if(snum[0] == 0x2d)
        numIsNeg = 1;

    for(idx = NUMLEN - 1; idx >= 0; idx--)
    {
        /* Only process numbers from 0 through 9. */
        if(snum[strIdx] >= 0x30 && snum[strIdx] <= 0x39)
            accum += (snum[strIdx] - 0x30) * pow(10, idx);

        strIdx++;
    }

    /* Check flag to see if originally passed -ve number and convert result if so. */
    if(!numIsNeg)
        return accum;
    else
        return accum * -1;
}

int main()
{
    /* Tests... */
    printf("Returned number is: %d\n", my_atoi("34574"));
    printf("Returned number is: %d\n", my_atoi("-23"));

    return 0;
}

สิ่งนี้จะทำสิ่งที่คุณต้องการโดยไม่เกะกะ

ฟังก์ชั่นนี้จะช่วยคุณ

int strtoint_n(char* str, int n)
{
    int sign = 1;
    int place = 1;
    int ret = 0;

    int i;
    for (i = n-1; i >= 0; i--, place *= 10)
    {
        int c = str[i];
        switch (c)
        {
            case '-':
                if (i == 0) sign = -1;
                else return -1;
                break;
            default:
                if (c >= '0' && c <= '9')   ret += (c - '0') * place;
                else return -1;
        }
    }

    return sign * ret;
}

int strtoint(char* str)
{
    char* temp = str;
    int n = 0;
    while (*temp != '\0')
    {
        n++;
        temp++;
    }
    return strtoint_n(str, n);
}

Ref: http://amscata.blogspot.com/2013/09/strnumstr-version-2.html

ตกลงฉันมีปัญหาเดียวกันฉันมาด้วยวิธีนี้มันทำงานได้ดีที่สุดสำหรับฉันฉันลอง atoi () แต่ไม่ได้ผลดีสำหรับฉันดังนั้นนี่คือวิธีแก้ปัญหาของฉัน:

void splitInput(int arr[], int sizeArr, char num[])
{
    for(int i = 0; i < sizeArr; i++)
        // We are subtracting 48 because the numbers in ASCII starts at 48.
        arr[i] = (int)num[i] - 48;
}

//I think this way we could go :
int my_atoi(const char* snum)
{
 int nInt(0);
 int index(0);
 while(snum[index])
 {
    if(!nInt)
        nInt= ( (int) snum[index]) - 48;
    else
    {
        nInt = (nInt *= 10) + ((int) snum[index] - 48);
    }
    index++;
 }
 return(nInt);
}

int main()
{
    printf("Returned number is: %d\n", my_atoi("676987"));
    return 0;
}

ใน C ++ คุณสามารถใช้ฟังก์ชันดังกล่าวได้:

template <typename T>
T to(const std::string & s)
{
    std::istringstream stm(s);
    T result;
    stm >> result;

    if(stm.tellg() != s.size())
        throw error;

    return result;
}

สิ่งนี้สามารถช่วยคุณแปลงสตริงให้เป็นชนิดใดก็ได้เช่น float, int, double ...

ใช่คุณสามารถเก็บจำนวนเต็มได้โดยตรง:

int num = 45;

หากคุณต้องแยกสตริงatoiหรือstrolจะชนะการประกวด "รหัสจำนวนที่สั้นที่สุด"