Ép kiểu trong C: chuyển đổi ngầm định và ép kiểu tường minh

C chuyển đổi giá trị giữa các kiểu liên tục. Một số phép chuyển đổi do bạn tự viết bằng ép kiểu (cast); phần lớn còn lại do trình biên dịch âm thầm thực hiện theo những quy tắc bạn không chọn. Biết phép nào là phép nào chính là khác biệt giữa câu hỏi "sao điểm trung bình của mình luôn là 3?" và code chạy đúng như những gì nó viết.

Chuyển đổi ngầm định

Mỗi khi một giá trị thuộc kiểu này gặp ngữ cảnh cần kiểu khác, C sẽ chuyển đổi nó:

#include <stdio.h>

int main(void) {
    int    i = 5;
    double d = i;        /* int -> double: 5.0, exact */
    char   c = 'A';
    int    code = c;     /* char -> int: 65 */
    double pi = 3.9;
    int    truncated = pi;   /* double -> int: 3, the .9 is gone */

    printf("d         = %f\n", d);
    printf("code      = %d\n", code);
    printf("truncated = %d\n", truncated);
    return 0;
}

Các phép chuyển đổi không thể làm mất thông tin (int sang double, char sang int, short sang long) là mở rộng và luôn an toàn. Các phép theo chiều ngược lại là thu hẹp và có thể làm mất dữ liệu: 3.9 ở trên trở thành 3 mà không có cảnh báo nào, trừ khi bạn yêu cầu bằng -Wconversion.

Các phép chuyển đổi số học thông thường

Khi một toán tử hai ngôi có toán hạng thuộc các kiểu khác nhau, C chuyển chúng về một kiểu chung trước khi tính. Thứ tự các bậc, từ dưới lên:

1. Mọi kiểu nhỏ hơn int (char, short, _Bool) được nâng lên int. Đây là nâng kiểu số nguyên (integer promotion) và nó luôn xảy ra trước tiên.
2. Nếu một bên là long double, bên kia trở thành long double.
3. Nếu không, nếu một bên là double, bên kia trở thành double.
4. Nếu không, nếu một bên là float, bên kia trở thành float.
5. Nếu không, giữa các kiểu số nguyên, kiểu có hạng cao hơn thắng, và nếu cùng hạng thì kiểu không dấu thắng.

Quy tắc cuối cùng đó là thứ gây ra bug thật. Các quy tắc còn lại đều dễ hiểu.

#include <stdio.h>

int main(void) {
    char a = 100, b = 100;

    /* a and b are promoted to int first, so 10000 fits fine. */
    printf("a * b as int = %d\n", a * b);

    /* But storing it back in a char narrows it again. */
    char product = a * b;
    printf("stored in char = %d\n", product);
    return 0;
}

Nâng kiểu số nguyên là lý do phép tính với char không bị tràn như bạn có thể nghĩ, và cũng là lý do lưu kết quả ngược lại vào một char thì bị tràn.

Ép kiểu tường minh

Phép ép kiểu là kiểu đích đặt trong cặp ngoặc tròn:

(double)x
(int)3.9
(char)65
(unsigned int)n

Nó áp dụng cho biểu thức ngay sau nó và có độ ưu tiên rất cao, cao hơn cả *, / hay +.

#include <stdio.h>

int main(void) {
    int total = 7, count = 2;

    printf("no cast:        %f\n", (double)(total / count));  /* 3.0 */
    printf("cast first:     %f\n", (double)total / count);    /* 3.5 */
    printf("cast both:      %f\n", (double)total / (double)count);
    return 0;
}

Dòng thứ nhất chia theo số nguyên (ra 3) rồi mới chuyển 3 thành 3.0: đã quá muộn. Dòng thứ hai chuyển total sang độ chính xác đủ để ra 3.5 trước phép chia, nên toán tử / thấy một double và một int, nâng kiểu int lên, và thực hiện phép chia số thực.

Ép kiểu một toán hạng là đủ. Các phép chuyển đổi số học thông thường sẽ lo phần còn lại.

Sửa lỗi chia số nguyên

Đây là lý do phổ biến nhất để viết một phép ép kiểu trong C:

#include <stdio.h>

int main(void) {
    int scores[] = {88, 92, 75, 61, 90};
    int n = 5;
    int sum = 0;

    for (int i = 0; i < n; i++) {
        sum += scores[i];
    }

    printf("sum = %d\n", sum);
    printf("wrong average: %f\n", (double)(sum / n));    /* 81.000000 - divided as ints, THEN converted */
    printf("right average: %f\n", (double)sum / n);      /* 81.200000 */

    /* Percentages have the same trap. */
    int passed = 3;
    printf("wrong pct: %d%%\n", passed / n * 100);            /* 0 percent */
    printf("right pct: %.1f%%\n", 100.0 * passed / n);        /* 60.0 percent */
    return 0;
}

Dòng tính phần trăm rất đáng chú ý: passed / n là 3 / 5, bằng 0 khi tính theo số nguyên, và 0 * 100 là 0. Nhân trước khi chia (100 * passed / n) sửa được lỗi này kể cả không cần ép kiểu, vì 300 / 5 chia hết, nhưng cách đó chỉ đúng khi các con số tình cờ thuận lợi. Ép kiểu mới là cách sửa đáng tin cậy.

Cắt bỏ, không làm tròn

Ép một giá trị số thực sang số nguyên sẽ bỏ phần thập phân. Nó cắt về phía 0, không làm tròn:

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

int main(void) {
    printf("(int) 3.2  = %d\n", (int) 3.2);
    printf("(int) 3.9  = %d\n", (int) 3.9);    /* 3, not 4 */
    printf("(int)-3.9  = %d\n", (int)-3.9);    /* -3, not -4 */

    /* Real rounding from math.h: */
    printf("round(3.9)  = %d\n", (int)round(3.9));    /* 4  */
    printf("round(-3.9) = %d\n", (int)round(-3.9));   /* -4 */
    printf("floor(3.9)  = %d\n", (int)floor(3.9));    /* 3  */
    printf("ceil(3.2)   = %d\n", (int)ceil(3.2));     /* 4  */
    return 0;
}

Nếu bạn biên dịch đoạn này trên máy của mình, nhớ rằng math.h cần -lm lúc liên kết trên Linux.

Thêm một mối nguy nữa: chuyển một giá trị số thực quá lớn so với kiểu số nguyên là undefined behavior, không phải quay vòng. (int)1e20 có thể cho ra bất cứ thứ gì. Hãy kiểm tra phạm vi trước khi ép kiểu khi giá trị không nằm trong tầm kiểm soát của bạn.

char và int

Trong C, char chính là một số nguyên nhỏ chứa mã ký tự. Chuyển đổi qua lại giữa hai kiểu là việc làm hằng ngày:

#include <stdio.h>

int main(void) {
    char letter = 'A';
    int code = letter;

    printf("'%c' has code %d\n", letter, code);
    printf("code + 1 is '%c'\n", (char)(code + 1));   /* 'B' */

    /* Digit character to its numeric value: */
    char digit = '7';
    int value = digit - '0';
    printf("the character '%c' as a number is %d\n", digit, value);

    /* Upper to lower, using the fixed 32-position gap in ASCII: */
    for (char ch = 'A'; ch <= 'E'; ch++) {
        printf("%c -> %c\n", ch, (char)(ch + 32));
    }
    return 0;
}

digit - '0' là cách viết chuẩn để biến một ký tự chữ số thành giá trị của nó, và nó đúng vì mười ký tự chữ số được đảm bảo nằm liên tiếp. Với chữ cái, hãy ưu tiên toupper() và tolower() trong ctype.h thay vì phép tính + 32: khoảng cách đó là đặc điểm của ASCII, không phải điều C đảm bảo.

Một cái bẫy liên quan: các hàm trong ctype.h như isdigit và toupper nhận một int phải là EOF hoặc biểu diễn được bằng unsigned char. Truyền một char thường mang giá trị âm (có thể xảy ra, vì char thường có thể là kiểu có dấu) là hành vi không xác định. Hãy ép kiểu: isdigit((unsigned char)c).

Bẫy có dấu và không dấu

Bậc 5 của thứ tự chuyển đổi, kiểu không dấu thắng khi cùng hạng, tạo ra phép so sánh gây bất ngờ nhất của C:

#include <stdio.h>

int main(void) {
    int          signed_val = -1;
    unsigned int unsigned_val = 1;

    if (signed_val < unsigned_val) {
        printf("-1 is less than 1  (what you expect)\n");
    } else {
        printf("-1 is NOT less than 1  (what C actually says)\n");
    }

    printf("(unsigned)-1 = %u\n", (unsigned int)signed_val);
    return 0;
}

-1 được chuyển sang unsigned int, tức là đọc lại dãy bit của nó thành 4.294.967.295. Số này lớn hơn 1, nên phép so sánh cho ra false.

Cùng phép chuyển đổi đó khiến vòng lặp chạy mãi không dừng:

/* BUG: i is unsigned, so i >= 0 is always true. When i is 0, i-- wraps. */
for (size_t i = n - 1; i >= 0; i--) { ... }

Và khiến việc kiểm tra độ dài thất bại:

/* BUG: strlen returns size_t (unsigned). If the string is shorter
   than 5, len - 5 wraps to a huge number and the test passes. */
if (strlen(s) - 5 > 0) { ... }

Viết lại thành if (strlen(s) > 5) thì phép trừ không bao giờ xảy ra.

Cách phòng tránh: giữ các biến đếm và chỉ số cùng một kiểu dấu xuyên suốt, biên dịch với -Wsign-compare (có sẵn trong -Wextra), và khi buộc phải trộn lẫn, hãy ép kiểu tường minh sau khi đã chắc chắn giá trị không thể âm.

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

int main(void) {
    const char *s = "hi";
    size_t len = strlen(s);

    /* Safe: compare without subtracting. */
    if (len > 5) {
        printf("long\n");
    } else {
        printf("short: %zu characters\n", len);
    }

    /* Safe: cast to a signed type once the value is known to be small. */
    int signed_len = (int)len;
    printf("len - 5 = %d\n", signed_len - 5);
    return 0;
}

Ép kiểu con trỏ

Ép kiểu cũng chuyển đổi giữa các kiểu con trỏ, và ở đây nó tiềm ẩn rủi ro thật sự vì nó thay đổi cách vùng nhớ được diễn giải, chứ không thay đổi bản thân các byte.

#include <stdio.h>

int main(void) {
    int value = 1;
    /* View the bytes of an int through a char pointer. */
    unsigned char *bytes = (unsigned char *)&value;

    printf("int 1 is stored as bytes:");
    for (size_t i = 0; i < sizeof(int); i++) {
        printf(" %02x", bytes[i]);
    }
    printf("\n");
    return 0;
}

Trên máy little-endian, đoạn này in ra 01 00 00 00. Xem cách biểu diễn của một đối tượng qua unsigned char * là một trong số ít phép ép kiểu con trỏ được chuẩn C cho phép rõ ràng.

Hầu hết các phép ép kiểu con trỏ khác thì không. Đọc một int qua float * vi phạm quy tắc strict aliasing và là undefined behavior dù vẫn biên dịch được; hãy dùng memcpy để diễn giải lại các byte.

Hai quy ước đáng biết. Trong C, void * chuyển sang và từ mọi kiểu con trỏ đối tượng không cần ép kiểu, đó là lý do bạn không nên ép kiểu kết quả của malloc:

int *arr = malloc(n * sizeof *arr);        /* correct C */
int *arr = (int *)malloc(n * sizeof *arr); /* needless; hides a missing header */

Phép ép kiểu là bắt buộc trong C++, nên rất nhiều code có nó. Trong C, nó có thể che giấu lỗi quên include <stdlib.h>.

Và printf("%p", ...) cần một void *, nên ở đó các đối số con trỏ thực sự cần ép kiểu: printf("%p", (void *)p).

Khi ép kiểu là câu trả lời sai

Ép kiểu khiến trình biên dịch im lặng. Đôi khi trình biên dịch đã đúng.

long big = 5000000000L;
int  small = (int)big;    /* the cast hides real data loss */

Nếu giá trị thực sự vừa, phép ép kiểu ghi nhận rằng bạn đã kiểm tra. Nếu có thể không vừa, phép ép kiểu đã biến một cảnh báo thành một kết quả sai âm thầm. Trước khi viết, hãy tự hỏi liệu cách sửa đúng có phải là đổi kiểu của biến: double thay vì int, size_t thay vì int, long long thay vì long. Ép kiểu chủ yếu là công cụ đúng khi hai kiểu đều đúng phải gặp nhau trong một phép tính, như (double)sum / count.