Đặc tả định dạng trong C: tra cứu đầy đủ printf và scanf

Một đặc tả định dạng (format specifier) cho printf biết cách biến một giá trị thành văn bản, và cho scanf biết cách biến văn bản thành giá trị. Đây là phần duy nhất của C mà mặc định trình biên dịch không giúp được bạn, vì hàm không nhìn thấy kiểu của các đối số, nên trang này là bảng để bạn đối chiếu.

Hình dạng tổng quát của một đặc tả là:

%[flags][width][.precision][length]conversion

Chỉ % và chữ cái chuyển đổi là bắt buộc. %-8.2lf dùng cả năm thành phần.

Bảng chuyển đổi

#include <stdio.h>

int main(void) {
    int x = 255;

    printf("%%d  : %d\n", x);
    printf("%%u  : %u\n", x);
    printf("%%x  : %x\n", x);
    printf("%%X  : %X\n", x);
    printf("%%o  : %o\n", x);
    printf("%%c  : %c\n", 65);
    printf("%%s  : %s\n", "text");
    printf("%%f  : %f\n", 3.5);
    printf("%%e  : %e\n", 3.5);
    printf("%%g  : %g\n", 3.5);
    printf("%%p  : %p\n", (void *)&x);
    return 0;
}

Có hai mục cần cảnh báo. %n ghi vào bộ nhớ thay vì in ra, và là cơ chế đứng sau lỗ hổng chuỗi định dạng (format-string vulnerability): đừng bao giờ để văn bản của người dùng lọt vào chuỗi định dạng. Còn %p đòi hỏi một void *; truyền thẳng một int * là không xác định dù mọi trình biên dịch thực tế vẫn in ra địa chỉ.

Bổ ngữ độ dài

Bổ ngữ độ dài (length modifier) nằm giữa độ chính xác và chữ cái chuyển đổi, và cho biết đối số thực sự lớn bao nhiêu.

Chuyển đổi có dấu (d i) và không dấu (u x o) nhận các kiểu khác nhau: %lu cần một unsigned long, không phải long, và nhầm lẫn ở đây là undefined behavior chứ không phải lỗi hiển thị nhỏ.

Và với nhóm số thực và ký tự:

Những tổ hợp bạn thực sự hay gõ:

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

int main(void) {
    short              s   = -12;
    long               l   = 3000000000L;
    long long          ll  = 9000000000000000000LL;
    unsigned long      ul  = 4000000000UL;
    unsigned long long ull = 18000000000000000000ULL;
    size_t             len = strlen("hello");
    long double        ld  = 2.5L;

    printf("short              : %hd\n", s);
    printf("long               : %ld\n", l);
    printf("long long          : %lld\n", ll);
    printf("unsigned long      : %lu\n", ul);
    printf("unsigned long long : %llu\n", ull);
    printf("size_t             : %zu\n", len);
    printf("long double        : %Lf\n", ld);
    return 0;
}

%zu là đặc tả cần thuộc lòng. sizeof, strlen và mọi kích thước của thư viện chuẩn đều trả về size_t, chiếm 8 byte trên hệ thống 64 bit trong khi int chiếm 4. printf("%d", strlen(s)) là một bug thật mà trông như vẫn chạy trên một số nền tảng, hãy dùng %zu.

Bổ ngữ hh và h tồn tại chủ yếu cho scanf, nơi kích thước đích quan trọng. Trong printf, một short được nâng lên int trước khi gọi, nên %d vẫn in đúng; %hd chỉ để thể hiện ý định.

Kiểu có độ rộng cố định

Với các kiểu trong <stdint.h> như int32_t, đặc tả có tính di động là các macro trong <inttypes.h>:

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

int main(void) {
    int32_t  a = -2000000000;
    uint64_t b = 18000000000000000000ULL;

    printf("int32_t  : %" PRId32 "\n", a);
    printf("uint64_t : %" PRIu64 "\n", b);
    return 0;
}

PRId32 khai triển thành đúng các chữ cái cho nền tảng của bạn, và các chuỗi literal đứng cạnh nhau được nối lại, vì thế chuỗi định dạng bị tách làm ba mảnh. Nó trông xấu; cách thay thế là ép kiểu sang long long và dùng %lld, thường dễ đọc hơn và luôn đúng.

Cờ

Cờ (flag) đứng ngay sau % và thay đổi cách trình bày. Chúng chỉ áp dụng cho printf.

#include <stdio.h>

int main(void) {
    printf("|%6d|\n",   42);
    printf("|%-6d|\n",  42);
    printf("|%06d|\n",  42);
    printf("|%+d|\n",   42);
    printf("|% d|\n",   42);
    printf("|%#x|\n",  255);
    printf("|%#o|\n",   64);
    printf("|%#.0f|\n", 3.0);
    return 0;
}

Các cờ có thể kết hợp: %-+8.2f là độ rộng tối thiểu 8, hai chữ số thập phân, luôn có dấu, đệm sau con số. Nếu viết cả hai thì - thắng 0.

Độ rộng và độ chính xác

Độ rộng (width) là kích thước tối thiểu của trường: đầu ra được đệm cho đủ, và không bao giờ bị cắt cho vừa. Độ chính xác (precision, đứng sau dấu chấm) mang nghĩa khác nhau với từng nhóm:

#include <stdio.h>

int main(void) {
    printf("|%10.3f|\n", 3.14159);     /* width 10, 3 decimals */
    printf("|%.5d|\n",   42);          /* minimum 5 digits     */
    printf("|%.3s|\n",   "abcdefg");   /* at most 3 chars      */
    printf("|%.0f|\n",   2.71828);     /* no decimals          */
    printf("|%*d|\n",    8, 42);       /* width from an argument */
    printf("|%.*f|\n",   3, 3.14159);  /* precision from an argument */
    return 0;
}

Một dấu * thay cho một trong hai con số sẽ lấy giá trị đó từ một đối số int, được đọc trước chính giá trị cần in. Đó là cách tạo bảng có độ rộng cột tính lúc chạy.

Trong scanf, độ rộng có một nhiệm vụ khác và quan trọng hơn nhiều: nó giới hạn lượng đầu vào mà một phép chuyển đổi tiêu thụ, và đó là thứ duy nhất đứng giữa %s và lỗi tràn bộ đệm.

printf và scanf khác nhau ở đâu

Chúng trông giống nhau nhưng khác nhau ở bốn chỗ. Mỗi chỗ đều là nguồn bug thực sự:

#include <stdio.h>

int main(void) {
    double d;
    char   word[16];

    printf("Enter a decimal number and a word: ");
    if (scanf("%lf %15s", &d, word) == 2) {   /* %lf and a width */
        printf("%.3f and \"%s\"\n", d, word); /* %f and a precision */
    } else {
        printf("Input did not match.\n");
    }
    return 0;
}

Hãy thử 2.5 hello. Chuỗi định dạng đọc nó và chuỗi định dạng in nó dùng chữ cái khác nhau cho cùng một double, và số 15 trong %15s giới hạn đầu vào ở 15 ký tự cộng ký tự kết thúc, đúng bằng kích thước của word.

Scanset của scanf

%[...] đọc một tập ký tự thay vì một từ ngăn cách bằng khoảng trắng. Đó là cách đọc cả một dòng bằng scanf, dù fgets vẫn là công cụ tốt hơn:

#include <stdio.h>

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

    printf("Type a sentence: ");
    if (scanf("%63[^\n]", line) == 1) {     /* everything up to a newline */
        printf("You typed: %s\n", line);
    }
    return 0;
}

[^\n] nghĩa là "mọi ký tự trừ ký tự xuống dòng". %[0-9] chỉ đọc chữ số, %[abc] chỉ đọc ba chữ cái đó. Khác với %s, scanset không bỏ qua khoảng trắng ở đầu, nên một ký tự xuống dòng còn sót trong bộ đệm khiến nó không khớp được gì cả.

Dùng sai là undefined behavior

printf không thể nhìn thấy kiểu thật của đối số. Nó đọc đúng số byte mà đặc tả ngụ ý và hiểu chúng theo cách đặc tả nói. Vì vậy dùng sai không phải là trục trặc hiển thị, mà là đọc bộ nhớ như một thứ khác:

printf("%d\n", 3.5);        /* prints garbage: reads a double's bits as int */
printf("%s\n", 42);         /* treats 42 as an address - crash */
printf("%d\n", strlen(s));  /* size_t read as int - wrong on 64-bit */
printf("%f\n", 3);          /* int read as double - garbage */

Cách phòng vệ chỉ tốn một cờ. Biên dịch với -Wall và GCC sẽ đối chiếu mọi chuỗi định dạng literal với các đối số của nó:

gcc -Wall -Wextra program.c -o program

Nó báo cả bốn dòng ở trên ngay lúc biên dịch. Đây là cảnh báo đáng giá nhất trong C, và được bật sẵn trong trình soạn thảo ở trên.

Về mặt thực hành khi dùng các đặc tả này, như căn bảng thẳng hàng, in số thực dễ đọc, đọc đầu vào mà không dính lỗi xuống dòng kinh điển, xem bài printf và scanf.