Toán tử trong C: số học, logic và độ ưu tiên

Toán tử (operator) là động từ của C: chúng nhận các giá trị và tạo ra giá trị mới. C có khoảng 40 toán tử, nhưng chỉ chừng một tá đã đủ cho phần lớn code, và hai trong số đó có những cái bẫy đủ nguy hiểm để đáng có phần riêng.

Toán tử số học

#include <stdio.h>

int main(void) {
    int a = 17, b = 5;

    printf("a + b  = %d\n", a + b);   /* 22 */
    printf("a - b  = %d\n", a - b);   /* 12 */
    printf("a * b  = %d\n", a * b);   /* 85 */
    printf("a / b  = %d\n", a / b);   /* 3  - integer division! */
    printf("a %% b  = %d\n", a % b);  /* 2  - the remainder */
    printf("-a     = %d\n", -a);      /* unary minus */
    return 0;
}

(%% trong chuỗi định dạng in ra một dấu phần trăm; nếu chỉ có % thì nó sẽ mở đầu một đặc tả định dạng.)

Năm toán tử số học hai ngôi là + - * / %, cộng thêm - một ngôi để đổi dấu và + một ngôi gần như không làm gì cả.

Cái bẫy chia số nguyên

a / b với hai số nguyên thực hiện phép chia số nguyên và bỏ đi phần dư. Không có làm tròn: kết quả bị cắt bớt về phía 0.

#include <stdio.h>

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

    printf("7 / 2         = %d\n", total / count);          /* 3 */
    printf("7 / 2.0       = %f\n", total / 2.0);            /* 3.5 */
    printf("(double)7 / 2 = %f\n", (double)total / count);  /* 3.5 */

    double wrong = total / count;      /* division happens FIRST, as ints */
    printf("wrong average = %f\n", wrong);   /* 3.000000 */
    return 0;
}

Trường hợp cuối cùng chính là bug lọt được tới môi trường production. Gán vào một biến double chẳng giúp gì: phép chia total / count đã tính xong, và đã là int, trước khi phép gán xảy ra. Cách sửa là biến một toán hạng thành số thực ngay bên trong biểu thức, thường bằng phép ép kiểu.

Hai quy tắc liên quan: chia số nguyên cho 0 là undefined behavior và thường làm chương trình crash, còn INT_MIN / -1 thì bị tràn số.

Toán tử chia lấy dư

% cho ra phần dư và chỉ dùng được với số nguyên:

#include <stdio.h>

int main(void) {
    for (int i = 1; i <= 10; i++) {
        if (i % 2 == 0) {
            printf("%d is even\n", i);
        } else {
            printf("%d is odd\n", i);
        }
    }

    int seconds = 3725;
    printf("\n%d seconds = %dh %dm %ds\n",
           seconds, seconds / 3600, (seconds % 3600) / 60, seconds % 60);
    return 0;
}

Kiểm tra số chẵn bằng x % 2 == 0 và dùng % n để chỉ số quay vòng trong một mảng là hai cách dùng hằng ngày.

Với số âm, % của C lấy theo dấu của số bị chia:

#include <stdio.h>

int main(void) {
    printf(" 7 %% 3 = %d\n",  7 % 3);   /*  1 */
    printf("-7 %% 3 = %d\n", -7 % 3);   /* -1, not 2 */
    printf(" 7 %% -3 = %d\n", 7 % -3);  /*  1 */
    return 0;
}

Vì vậy x % 2 == 1 là một phép kiểm tra số lẻ bị sai khi x có thể âm: -7 % 2 bằng -1. Hãy dùng x % 2 != 0.

Với phần dư của số thực, % gây lỗi biên dịch; hãy dùng fmod() trong math.h.

Phép gán và phép gán kết hợp

= lưu một giá trị. Các dạng kết hợp gộp một phép toán với việc lưu:

#include <stdio.h>

int main(void) {
    int x = 10;

    x += 5;   printf("x += 5   -> %d\n", x);   /* 15 */
    x -= 3;   printf("x -= 3   -> %d\n", x);   /* 12 */
    x *= 2;   printf("x *= 2   -> %d\n", x);   /* 24 */
    x /= 4;   printf("x /= 4   -> %d\n", x);   /* 6  */
    x %= 4;   printf("x %%= 4   -> %d\n", x);  /* 2  */
    return 0;
}

x += 5 nghĩa là x = x + 5, nhưng nó chỉ tính x một lần, điều này quan trọng khi đích là một thứ như arr[compute_index()].

Bản thân phép gán cũng là một biểu thức cho ra giá trị vừa gán, đó là lý do a = b = c = 0 chạy được (nó gán từ phải sang trái) và cũng là lý do lỗi nhầm = với == vẫn biên dịch mà không báo gì.

Tăng và giảm

++ cộng một, -- trừ một. Mỗi toán tử có dạng tiền tố và dạng hậu tố:

#include <stdio.h>

int main(void) {
    int i = 5;
    int a = i++;    /* a gets 5 (the old value), then i becomes 6 */
    printf("postfix: a = %d, i = %d\n", a, i);

    int j = 5;
    int b = ++j;    /* j becomes 6 first, then b gets 6 */
    printf("prefix:  b = %d, j = %d\n", b, j);

    int k = 5;
    k++;            /* as a statement on its own, identical to ++k */
    printf("statement: k = %d\n", k);
    return 0;
}

Khi đứng thành câu lệnh riêng, hai dạng có thể thay cho nhau, và i++ là lựa chọn quen thuộc trong phần đầu vòng lặp for chỉ vì thói quen chứ không vì lý do sâu xa nào.

Điều bạn tuyệt đối không được làm là dùng một biến nhiều lần trong biểu thức mà chính biến đó cũng bị thay đổi:

int i = 5;
int x = i++ + i++;      /* undefined behavior */
arr[i] = i++;           /* undefined behavior */
printf("%d %d", i++, i);/* undefined behavior */

C không quy định thứ tự tính các biểu thức con đó, nên kết quả không chỉ đơn giản là không xác định: hành vi của cả chương trình là undefined. Tách câu lệnh làm hai thì sự mơ hồ biến mất.

Toán tử so sánh

Có sáu toán tử, và tất cả đều cho ra một int: 1 cho đúng và 0 cho sai.

#include <stdio.h>

int main(void) {
    int a = 5, b = 8;

    printf("a == b : %d\n", a == b);   /* 0 */
    printf("a != b : %d\n", a != b);   /* 1 */
    printf("a <  b : %d\n", a <  b);   /* 1 */
    printf("a >  b : %d\n", a >  b);   /* 0 */
    printf("a <= 5 : %d\n", a <= 5);   /* 1 */
    printf("a >= 9 : %d\n", a >= 9);   /* 0 */
    return 0;
}

Việc kết quả là một int bình thường chứ không phải một kiểu boolean riêng là một đặc trưng của C. Xem bài boolean trong C để biết những hệ quả của nó, kể cả bug nhầm = với ==.

Có hai lỗi so sánh chỉ riêng C mới có. So sánh nối tiếp không hoạt động như trong toán học: if (1 < x < 10) luôn đúng, vì 1 < x cho ra 0 hoặc 1 rồi kết quả đó mới được so với 10. Hãy viết if (x > 1 && x < 10). Và so sánh chuỗi bằng == là so sánh con trỏ chứ không phải nội dung: hãy dùng strcmp trong string.h.

Toán tử logic

#include <stdio.h>

int main(void) {
    int age = 25;
    int has_license = 1;

    if (age >= 18 && has_license) {
        printf("May drive\n");
    }

    if (age < 13 || age > 65) {
        printf("Discounted ticket\n");
    } else {
        printf("Full price\n");
    }

    printf("!has_license = %d\n", !has_license);   /* 0 */
    printf("!0 = %d\n", !0);                       /* 1 */
    return 0;
}

&& là AND, || là OR, ! là NOT. Cả ba đều coi mọi giá trị khác 0 là đúng.

Chúng đánh giá ngắn mạch (short-circuit): && dừng ngay khi một toán hạng sai, còn || dừng ngay khi một toán hạng đúng. Phần còn lại không bao giờ được tính, và đây không chỉ là một cách tối ưu: đó là một đảm bảo bạn có thể dựa vào để giữ an toàn:

#include <stdio.h>

int is_safe(int *p) {
    /* If p is NULL, *p is never evaluated - the && stops first. */
    return p != NULL && *p > 0;
}

int main(void) {
    int value = 7;
    printf("with a real pointer: %d\n", is_safe(&value));
    printf("with NULL:           %d\n", is_safe(NULL));
    return 0;
}

Đổi thứ tự hai phép kiểm tra đó thì lời gọi với NULL sẽ dereference một con trỏ null và crash. Kiểm tra trước, dùng sau: thứ tự trong một chuỗi && là một phần của logic.

Toán tử điều kiện

Toán tử ba ngôi duy nhất của C chọn giữa hai giá trị:

#include <stdio.h>

int main(void) {
    int a = 12, b = 30;

    int max = (a > b) ? a : b;
    printf("max = %d\n", max);

    printf("%d item%s\n", a, (a == 1) ? "" : "s");
    return 0;
}

condition ? value_if_true : value_if_false. Đây là một biểu thức, nên nó đặt được ở những chỗ câu lệnh if không đặt được: trong một đối số của printf, trong một giá trị khởi tạo. Hãy viết ngắn gọn; toán tử điều kiện lồng nhau rất nhanh trở nên khó đọc.

Sơ lược về toán tử bit

Các toán tử này làm việc trên từng bit của một số nguyên:

#include <stdio.h>

int main(void) {
    unsigned int a = 12;   /* 1100 in binary */
    unsigned int b = 10;   /* 1010 */

    printf("a & b  = %u\n", a & b);    /* 8  - 1000, AND */
    printf("a | b  = %u\n", a | b);    /* 14 - 1110, OR  */
    printf("a ^ b  = %u\n", a ^ b);    /* 6  - 0110, XOR */
    printf("~a     = %u\n", ~a);       /* NOT - flips every bit */
    printf("a << 2 = %u\n", a << 2);   /* 48 - shift up, multiplies by 4 */
    printf("a >> 2 = %u\n", a >> 2);   /* 3  - shift down, divides by 4 */
    return 0;
}

Chúng được dùng cho cờ, mặt nạ bit và thanh ghi phần cứng. Có hai lưu ý: & và | không phải && và || (chúng không đánh giá ngắn mạch và làm việc theo từng bit), và dịch bit một giá trị có dấu hoặc dịch nhiều hơn độ rộng của kiểu là undefined. Hãy dùng kiểu không dấu khi làm việc với bit.

Độ ưu tiên

Khi biểu thức không có dấu ngoặc, bảng này quyết định cái gì gắn với cái gì. Độ ưu tiên cao nhất đứng đầu:

Hệ quả thực tế:

a + b * c       /* means a + (b * c) */
a < b == c < d  /* means (a < b) == (c < d) - rarely what you meant */
x & 1 == 0      /* means x & (1 == 0), i.e. x & 0 - a classic bug */
*p++            /* means *(p++) - dereference p, then advance it */

Dòng thứ ba đáng để thuộc lòng: == gắn chặt hơn &, nên phép kiểm tra mặt nạ bit cần dấu ngoặc: (x & 1) == 0.

Không ai nhớ hết mười lăm mức, và cũng chẳng ai cần nhớ. Chỉ cần biết * thắng +, phép so sánh thắng &&, && thắng ||, và mọi thứ còn lại thì thêm dấu ngoặc:

if ((flags & MASK) != 0 && (count > 0 || force)) { ... }

Dòng đó có những dấu ngoặc thừa, và nhờ vậy mà nó tốt hơn.