Chuyển chuỗi sang int trong C: atoi, strtol và đổi số thành chuỗi

Văn bản từ người dùng, từ tệp và từ dòng lệnh đều đến dưới dạng ký tự. "42" là ba byte, gồm '4', '2', '\0', và chưa có gì trong đó là con số 42 cho đến khi bạn chuyển đổi nó. C có hai thế hệ hàm chuyển đổi: nhóm cũ, ngắn gọn nhưng không báo được lỗi, và nhóm dài hơn nhưng báo được. Trang này trình bày cả hai và giải thích vì sao chương trình thực tế dùng nhóm thứ hai.

Nhóm hàm cũ: atoi, atol, atof

Tên hàm nói lên công dụng: ASCII sang int, sang long, sang double. Một đối số (argument), một kết quả.

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

int main(void) {
    printf("%d\n", atoi("42"));
    printf("%d\n", atoi("  -17 trailing junk"));
    printf("%f\n", atof("3.14"));
    return 0;
}

Khoảng trắng ở đầu bị bỏ qua, dấu tùy chọn được đọc, các chữ số được tiêu thụ, và mọi thứ phía sau bị bỏ qua. Như vậy rất tiện, cho đến khi đầu vào sai:

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

int main(void) {
    printf("atoi(\"0\")     = %d\n", atoi("0"));
    printf("atoi(\"hello\") = %d\n", atoi("hello"));
    printf("atoi(\"\")      = %d\n", atoi(""));
    return 0;
}

Cả ba dòng đều in ra 0. Không có mã trả về, không có cờ báo, không có cách nào hỏi "chuyển đổi có thành công không?", và một giá trị vượt quá phạm vi int là undefined behavior chứ không phải một lỗi được báo. Với một hằng số viết sẵn trong chương trình đồ chơi thì còn chấp nhận được. Với bất cứ thứ gì do người dùng hay tệp cung cấp, đây là nguồn sinh bug âm thầm.

Công cụ đúng: strtol

strtol (string to long) làm cùng phép chuyển đổi nhưng có hai kênh để báo chuyện gì đã xảy ra.

long strtol(const char *text, char **endptr, int base);

endptr được gán bằng ký tự đầu tiên mà hàm không tiêu thụ. base là cơ số: dùng 10, hoặc 0 để tiền tố của chính số đó quyết định (0x cho hệ thập lục phân, 0 ở đầu cho hệ bát phân).

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

int main(void) {
    const char *input = "42 apples";
    char *end;

    long value = strtol(input, &end, 10);

    printf("value = %ld\n", value);
    printf("stopped at: \"%s\"\n", end);
    printf("consumed %td characters\n", end - input);
    return 0;
}

Đọc endptr sẽ trả lời những câu hỏi mà atoi không trả lời được:

• end == input nghĩa là không có gì được chuyển đổi: văn bản không bắt đầu bằng một số.
• *end != '\0' nghĩa là còn nội dung phía sau. Đó có phải lỗi hay không là do bạn quyết định: không sao khi phân tích "42 apples", nhưng là vấn đề khi cả dòng lẽ ra phải là một số.

Tràn số được báo riêng qua errno. Cách viết đầy đủ và đúng đáng để viết một lần rồi dùng lại:

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

/* returns 1 on success, 0 on any kind of failure */
int parse_int(const char *text, int *out) {
    char *end;
    errno = 0;

    long value = strtol(text, &end, 10);

    if (end == text) {
        return 0;                 /* no digits at all */
    }
    if (*end != '\0') {
        return 0;                 /* trailing junk */
    }
    if (errno == ERANGE || value < INT_MIN || value > INT_MAX) {
        return 0;                 /* out of range for an int */
    }

    *out = (int)value;
    return 1;
}

int main(void) {
    const char *tests[] = {"42", "-7", "hello", "", "9999999999", "12abc"};
    int n = (int)(sizeof tests / sizeof tests[0]);

    for (int i = 0; i < n; i++) {
        int value;
        if (parse_int(tests[i], &value)) {
            printf("\"%s\" -> %d\n", tests[i], value);
        } else {
            printf("\"%s\" -> rejected\n", tests[i]);
        }
    }
    return 0;
}

Ba chi tiết làm cho đoạn code này đúng. Gán errno = 0 trước khi gọi là cần thiết vì thư viện chỉ gán errno chứ không bao giờ xóa nó, nên một giá trị cũ từ lần gọi trước sẽ bị hiểu nhầm là lỗi của lần gọi này. strtol trả về long, có thể rộng hơn int, nên việc kiểm tra phạm vi với INT_MIN/INT_MAX tách biệt với ERANGE. Và trả về trạng thái thành công trong khi đưa giá trị ra qua con trỏ là cách các hàm C báo "hoặc có giá trị, hoặc thất bại": giá trị trả về không thể làm cả hai việc.

strtoul là phiên bản không dấu, còn strtoll/strtoull xử lý long long.

Các cơ số khác

Cơ số 16 đọc số thập lục phân; cơ số 0 xem tiền tố rồi tự quyết định. Để kiểm tra một chuỗi có nghĩa là gì ở cơ số khác, hãy dán nó vào công cụ chuyển đổi cơ số.

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

int main(void) {
    char *end;

    printf("%ld\n", strtol("ff", &end, 16));      /* 255 */
    printf("%ld\n", strtol("0x1A", &end, 0));     /* 26, prefix detected */
    printf("%ld\n", strtol("1011", &end, 2));     /* 11, binary */
    printf("%ld\n", strtol("755", &end, 8));      /* 493, octal */
    return 0;
}

Cơ số 0 là một cái bẫy trong một trường hợp cụ thể: số thập phân có số 0 đứng đầu như "012" bị đọc thành bát phân và cho ra 10. Nếu đầu vào là số thập phân, hãy ghi rõ 10.

Số thực: strtod

strtod có cùng cách dùng nhưng cho double, và atof có cùng khuyết điểm như atoi.

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

int main(void) {
    const char *text = "3.14159 rest";
    char *end;
    errno = 0;

    double value = strtod(text, &end);

    if (end == text) {
        printf("not a number\n");
    } else if (errno == ERANGE) {
        printf("out of range\n");
    } else {
        printf("value = %f, stopped at \"%s\"\n", value, end);
    }
    return 0;
}

strtod cũng nhận ký hiệu khoa học ("1.5e3"), số thực dạng hex, và các từ "inf" và "nan". Locale ảnh hưởng tới dấu phân cách thập phân, điều này hay làm người ta bất ngờ khi đọc tệp được tạo ở nơi khác. Với locale "C" mặc định, dấu phân cách luôn là dấu chấm.

Số thành chuỗi: snprintf

Theo chiều ngược lại, snprintf là lựa chọn chuẩn. Hàm này ghi tối đa đúng kích thước bạn đưa, luôn thêm ký tự kết thúc, và trả về độ dài mà kết quả đầy đủ lẽ ra cần.

#include <stdio.h>

int main(void) {
    char buf[32];
    int n = 4095;

    int written = snprintf(buf, sizeof buf, "%d", n);
    printf("text: \"%s\" (needed %d chars)\n", buf, written);

    snprintf(buf, sizeof buf, "%05d", n);
    printf("padded: %s\n", buf);

    snprintf(buf, sizeof buf, "%x / %o / %.2f", n, n, n / 1000.0);
    printf("mixed:  %s\n", buf);
    return 0;
}

Giá trị trả về chính là cách kiểm tra bị cắt. Nếu nó lớn hơn hoặc bằng kích thước buffer, văn bản đã không vừa:

#include <stdio.h>

int main(void) {
    char small[8];

    int needed = snprintf(small, sizeof small, "value=%d", 1234567);

    if (needed < 0) {
        printf("encoding error\n");
    } else if ((size_t)needed >= sizeof small) {
        printf("truncated: \"%s\" (needed %d bytes)\n", small, needed + 1);
    } else {
        printf("ok: %s\n", small);
    }
    return 0;
}

Hai thứ không nên dùng: itoa không thuộc chuẩn C, nên code dùng nó sẽ không biên dịch được ở mọi nơi; còn sprintf là snprintf không có giới hạn kích thước, nghĩa là nó sẽ ghi tràn qua cuối buffer mà không hề báo gì.

Ký tự đơn lẻ và '0'

Các ký tự chữ số từ '0' đến '9' được đảm bảo nằm liên tiếp nhau, nên một phép trừ đơn giản là đủ để chuyển qua lại giữa ký tự chữ số và giá trị của nó.

#include <stdio.h>
#include <ctype.h>

int main(void) {
    char c = '7';
    int digit = c - '0';
    printf("char '%c' -> int %d\n", c, digit);

    int value = 3;
    char back = (char)(value + '0');
    printf("int %d -> char '%c'\n", value, back);
    return 0;
}

Chỉ chữ số mới có tính chất này: chữ cái không bắt buộc phải liên tiếp, nên c - 'a' không khả chuyển khi tính toán trên bảng chữ cái. Hãy kiểm tra bằng isdigit trước khi tin vào phép trừ:

#include <stdio.h>
#include <ctype.h>

int main(void) {
    char text[] = "a1b2c3";
    int sum = 0;

    for (int i = 0; text[i] != '\0'; i++) {
        if (isdigit((unsigned char)text[i])) {
            sum += text[i] - '0';
        }
    }

    printf("digits sum to %d\n", sum);
    return 0;
}

Ép kiểu sang unsigned char là bắt buộc vì cùng lý do như với chuỗi: các hàm trong <ctype.h> có hành vi không xác định với đối số âm, và char thường có thể là kiểu có dấu.

Nên dùng hàm nào

• Văn bản từ người dùng, từ tệp hoặc argv → strtol / strtod với đầy đủ bước kiểm tra.
• Một hằng số bạn tự viết và kiểm soát → atoi chấp nhận được, dù không có gì nổi bật.
• Số vào buffer → snprintf, và kiểm tra giá trị trả về.
• Một ký tự chữ số → trừ '0', sau khi kiểm tra isdigit.
• Không bao giờ dùng → gets, sprintf, itoa.