scanf trong C: nhập dữ liệu, quy tắc & và vì sao nó ngừng chạy

scanf là hình ảnh phản chiếu của printf: cùng tệp header, chuỗi định dạng trông giống nhau, nhưng đi theo chiều ngược lại. Nó đọc văn bản từ đầu vào chuẩn, chuyển đổi theo chuỗi định dạng, rồi lưu kết quả qua các con trỏ bạn đưa cho nó.

Đây cũng là hàm khiến người mới học C bối rối nhiều hơn bất kỳ hàm nào khác, vì ba hành vi của nó gây bất ngờ và một trong số đó là lỗ hổng bảo mật. Trang này nói về cả bốn.

Dạng cơ bản, và vì sao cần &

#include <stdio.h>

int main(void) {
    int age;

    printf("Enter your age: ");
    scanf("%d", &age);

    printf("Next year you will be %d.\n", age + 1);
    return 0;
}

Gõ một số rồi nhấn Enter để chạy đoạn này. &age không phải để trang trí. C truyền mọi đối số theo giá trị, nên nếu bạn viết scanf("%d", age), hàm sẽ nhận một bản sao giá trị hiện tại (rác) của age và không có cách nào chạm tới chính biến đó. &age truyền địa chỉ của biến, và scanf ghi vào qua địa chỉ đó. Xem trang con trỏ để hiểu đầy đủ.

Bỏ sót & là lỗi scanf phổ biến nhất. Trình biên dịch với -Wall bắt được lỗi này (format '%d' expects argument of type 'int *'); nếu không bật cảnh báo, code vẫn biên dịch và làm hỏng bộ nhớ ở một địa chỉ ngẫu nhiên nào đó.

Đọc nhiều giá trị

Một lời gọi có thể đọc nhiều giá trị. Khoảng trắng trong đầu vào, gồm dấu cách, tab và xuống dòng, ngăn cách chúng, và các đặc tả số bỏ qua khoảng trắng bất kể bao nhiêu.

#include <stdio.h>

int main(void) {
    int    day, month, year;

    printf("Enter a date as DD MM YYYY: ");
    if (scanf("%d %d %d", &day, &month, &year) != 3) {
        printf("That was not three numbers.\n");
        return 1;
    }

    printf("%04d-%02d-%02d\n", year, month, day);
    return 0;
}

Các dấu cách trong "%d %d %d" thật ra là thừa, vì %d vốn đã bỏ qua khoảng trắng ở đầu, nhưng chúng giúp chuỗi định dạng dễ đọc. Thứ không thừa là kiểm tra giá trị trả về, sẽ nói ở phần dưới.

Các ký tự không phải khoảng trắng trong chuỗi định dạng phải khớp chính xác với đầu vào, và đó là cách đọc dữ liệu có cấu trúc:

#include <stdio.h>

int main(void) {
    int h, m;

    printf("Enter a time as HH:MM: ");
    if (scanf("%d:%d", &h, &m) == 2) {
        printf("%d hours and %d minutes\n", h, m);
    } else {
        printf("Could not parse that.\n");
    }
    return 0;
}

Dấu : trong chuỗi định dạng đòi hỏi một dấu : trong đầu vào. Gõ 9:30 thì phân tích được; gõ 9 30 thì thất bại sau khi đọc 9.

Luôn kiểm tra giá trị trả về

scanf trả về số mục đã gán thành công, không phải số ký tự, cũng không phải một cờ báo thành công. Nó trả về EOF nếu đầu vào kết thúc trước khi chuyển đổi được gì.

#include <stdio.h>

int main(void) {
    int n;

    printf("Enter a number: ");
    int result = scanf("%d", &n);

    if (result == 1) {
        printf("Got %d\n", n);
    } else if (result == 0) {
        printf("That was not a number.\n");
    } else {
        printf("Input ended.\n");
    }
    return 0;
}

Gõ hello ở dấu nhắc. scanf trả về 0, n được giữ nguyên, vẫn chứa giá trị rác ban đầu, và đoạn văn bản gây lỗi vẫn nằm trong luồng đầu vào. Chính điểm cuối này biến một lần nhập sai thành một vòng lặp vô hạn:

/* BUG: spins forever on non-numeric input */
while (scanf("%d", &n) != 1) {
    printf("Try again: ");
}

scanf không bao giờ tiêu thụ đoạn văn bản nó không chuyển đổi được, nên lời gọi tiếp theo lại thất bại trên đúng các ký tự đó, mãi mãi. Để khôi phục, bạn phải tự bỏ phần còn lại của dòng:

#include <stdio.h>

/* Throw away everything up to and including the next newline. */
static void discard_line(void) {
    int c;
    while ((c = getchar()) != '\n' && c != EOF) {
        /* nothing */
    }
}

int main(void) {
    int n;
    int r;

    printf("Enter a number: ");
    while ((r = scanf("%d", &n)) != 1) {
        if (r == EOF) {
            printf("\nNo more input.\n");
            return 1;
        }
        discard_line();
        printf("Not a number. Try again: ");
    }

    printf("Got %d\n", n);
    return 0;
}

Việc kiểm tra EOF rất quan trọng: khi luồng đầu vào kết thúc (người dùng nhấn Ctrl+D, hoặc tệp được pipe vào đã hết), scanf sẽ trả về EOF mãi từ đó về sau, nên một vòng lặp chỉ kiểm tra != 1 sẽ thử lại vô tận. Hãy xử lý "nhập sai" và "hết dữ liệu nhập" như hai trường hợp khác nhau, đúng bản chất của chúng. Khi đã có phần đó, hàm phụ discard_line đáng để giữ lại trong mọi chương trình dùng scanf cho dữ liệu do người gõ.

Tràn bộ đệm với %s

%s đọc ký tự vào một mảng char. Lưu ý là không có &: tên mảng vốn đã suy biến thành con trỏ tới phần tử đầu tiên, nên &name sẽ sai kiểu.

Vấn đề là %s trơn không biết mảng của bạn lớn bao nhiêu:

char name[10];
scanf("%s", name);      /* DANGEROUS: types 40 characters, writes 41 bytes */

Không có gì dừng việc ghi ở cuối mảng. Nó ghi tiếp vào bất cứ thứ gì nằm kế tiếp trong bộ nhớ, như các biến khác hay địa chỉ trả về, và đó là lỗi tràn bộ đệm (buffer overflow) kinh điển, trong lịch sử là loại bug bị khai thác nhiều nhất trong C. Cách sửa là một độ rộng đặt giữa % và s, nhỏ hơn kích thước mảng một đơn vị để chừa chỗ cho ký tự kết thúc '\0':

#include <stdio.h>

int main(void) {
    char name[20];

    printf("Enter your first name: ");
    if (scanf("%19s", name) == 1) {     /* 19 chars + '\0' = 20 */
        printf("Hello, %s!\n", name);
    }
    return 0;
}

Độ rộng phải được viết dưới dạng literal trong chuỗi định dạng, nên khá phiền để giữ nó khớp với kích thước mảng. Đó thêm một lý do khiến phần lớn code C trong thực tế dùng fgets.

Điều bất ngờ thứ hai của %s: nó dừng ở khoảng trắng đầu tiên. Gõ Ada Lovelace thì name chứa Ada; Lovelace nằm chờ trong luồng cho lần đọc tiếp theo. %s đọc một từ, không phải một dòng.

Bug ký tự xuống dòng còn sót

Đây chính là lỗi "scanf không chạy" mà ai cũng gặp. Các đặc tả số bỏ qua khoảng trắng ở đầu; %c thì không.

#include <stdio.h>

int main(void) {
    int age;
    char initial;

    printf("Enter your age: ");
    scanf("%d", &age);

    printf("Enter your initial: ");
    scanf(" %c", &initial);      /* the leading space is the whole fix */

    printf("%c is %d years old.\n", initial, age);
    return 0;
}

Đây là điều xảy ra khi không có dấu cách đó. Bạn gõ 30 rồi nhấn Enter. %d tiêu thụ 3 và 0 rồi dừng ở ký tự xuống dòng, để lại '\n' trong bộ đệm. Lệnh scanf("%c", &initial) tiếp theo đọc ký tự xuống dòng đó làm ký tự cần nhập và trả về ngay lập tức: dấu nhắc vừa hiện ra đã bị bỏ qua.

Một dấu cách trong chuỗi định dạng của scanf nghĩa là "bỏ qua mọi khoảng trắng ở đây", nên " %c" bước qua ký tự xuống dòng lạc lõng và chờ một ký tự thật. Dấu cách chỉ cần đặt trước %c và %[; mọi đặc tả khác tự bỏ qua khoảng trắng.

Đọc số thực và ký tự

Phần lớn các đặc tả dùng chung với printf, với một khác biệt quan trọng: scanf cần biết chính xác kích thước của biến đích, vì nó ghi qua một con trỏ.

#include <stdio.h>

int main(void) {
    float  f;
    double d;
    int    i;
    char   c;

    printf("Enter a float, a double, an int and a char: ");
    if (scanf("%f %lf %d %c", &f, &d, &i, &c) == 4) {
        printf("%.2f %.4f %d %c\n", f, d, i, c);
    } else {
        printf("Input did not match.\n");
    }
    return 0;
}

Thử nhập 1.5 2.25 7 x.

%f đọc một float, %lf đọc một double. Trong printf cả hai in giống nhau vì float được nâng lên double trước lời gọi, nhưng trong scanf không có việc nâng kiểu, và dùng %f với một double * sẽ ghi bốn byte vào một biến tám byte, làm hỏng giá trị của nó. %c ở đây không cần dấu cách phía trước vì %d trước nó đã dừng ở một dấu cách, không phải ký tự xuống dòng. (Bảng đầy đủ ở trang đặc tả định dạng.)

fgets: lựa chọn chắc chắn hơn

Với mọi thứ do con người gõ, hãy đọc cả dòng rồi mới phân tích. fgets nhận kích thước bộ đệm làm đối số, nên về mặt vật lý không thể tràn, và khi dòng vừa đủ chỗ, nó đọc luôn cả ký tự xuống dòng, nên không còn gì sót lại làm rối lần đọc sau. (Một dòng dài hơn bộ đệm sẽ để phần đuôi chưa đọc; việc thiếu '\n' trong thứ bạn nhận được là cách phát hiện điều đó.)

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

int main(void) {
    char line[128];

    printf("Enter your full name: ");
    if (fgets(line, sizeof line, stdin) == NULL) {
        return 1;
    }
    line[strcspn(line, "\n")] = '\0';     /* trim the newline fgets keeps */
    printf("Hello, %s!\n", line);

    printf("Enter your age: ");
    if (fgets(line, sizeof line, stdin) == NULL) {
        return 1;
    }
    int age = (int)strtol(line, NULL, 10);
    printf("Next year: %d\n", age + 1);
    return 0;
}

Ba điểm về cách làm này:

• sizeof line truyền kích thước thật, nên khi đổi kích thước mảng không cần sửa thêm chỗ nào, khác với literal %19s.
• fgets giữ lại ký tự xuống dòng nếu dòng vừa đủ chỗ, đó là lý do có bước cắt bằng strcspn. Đó cũng là cách phát hiện một dòng quá dài so với bộ đệm: không có '\n' trong thứ bạn nhận được.
• Phân tích sau. strtol cho số nguyên (nó còn cho bạn biết việc phân tích dừng ở đâu), strtod cho số thực, hoặc sscanf(line, "%d %d", &a, &b) để dùng định dạng của scanf trên một chuỗi bạn đã nắm giữ an toàn.

sscanf xứng đáng được nhắc riêng: đó là scanf đọc từ một chuỗi thay vì luồng đầu vào, và nó kết hợp hoàn hảo với fgets. Bạn có được khả năng phân tích tiện lợi của scanf mà không gặp vấn đề nào về luồng.

Lỗi thường gặp

• Quên & với đối số không phải mảng. Hãy biên dịch với -Wall.
• %s không có độ rộng. Một lỗi tràn bộ đệm chỉ chờ một lần nhập dài.
• Bỏ qua giá trị trả về. Rồi đọc một biến mà scanf chưa bao giờ gán.
• Lặp lại một scanf thất bại mà không bỏ đầu vào cũ. Một vòng lặp vô hạn.
• %c không có dấu cách phía trước sau khi đọc một số. Bug dấu nhắc bị bỏ qua.
• Dùng %f cho một double. Hỏng dữ liệu âm thầm; scanf cần %lf.
• Tưởng %s đọc cả một dòng. Nó chỉ đọc một từ, ngăn cách bởi khoảng trắng.