Hằng số trong C: const, #define và enum

Hằng số (constant) là một giá trị có tên kèm lời hứa rằng nó sẽ không thay đổi. C cho bạn ba cơ chế để làm điều đó, và bên dưới chúng thực sự là những thứ khác nhau: một là biến, một là thay thế văn bản, và một là kiểu số nguyên.

Vì sao phải đặt tên cho giá trị

So sánh hai dòng sau:

double area = 3.14159 * r * r;
double area = PI * r * r;

Dòng thứ hai tốt hơn vì ba lý do mà sau này đều sẽ lộ ra. Nó nói rõ con số mang ý nghĩa gì. Nó chỉ xuất hiện ở đúng một chỗ, nên đổi độ chính xác chỉ cần sửa một lần thay vì đi tìm khắp nơi. Và gõ nhầm PI là một lỗi biên dịch, còn gõ nhầm 3.14195 là một kết quả sai.

Những con số không tên rải rác trong code được gọi là magic number, và loại bỏ chúng là một trong những cải tiến rẻ nhất bạn có thể làm cho một chương trình C.

const

Từ khóa const đánh dấu một biến là chỉ đọc:

#include <stdio.h>

int main(void) {
    const double PI = 3.14159265358979;
    const int MAX_USERS = 100;

    double r = 2.0;
    printf("Area of r=%.1f: %.4f\n", r, PI * r * r);
    printf("Capacity: %d users\n", MAX_USERS);

    /* PI = 3.0;  <- uncomment this line and the program will not compile */
    return 0;
}

Bỏ chú thích ở lệnh gán và trình biên dịch sẽ từ chối: assignment of read-only variable 'PI'. Lỗi đó xuất hiện ngay lúc build, và đó chính là mục đích.

Một biến const là một biến thật. Nó có kiểu, nên trình biên dịch kiểm tra cách bạn dùng nó. Nó tuân theo phạm vi, nên một const bên trong hàm không lọt ra ngoài. Nó có địa chỉ, nên bạn có thể lấy con trỏ tới nó. Và trình gỡ lỗi có thể hiển thị tên và giá trị của nó.

const phải được khởi tạo ngay tại chỗ khai báo, không có cơ hội thứ hai:

const int limit;       /* error (or garbage forever): nothing can assign to it later */
const int limit = 50;  /* correct */

#define

Cách thay thế bằng tiền xử lý là một macro:

#include <stdio.h>

#define PI 3.14159265358979
#define MAX_USERS 100
#define GREETING "Welcome to the system"

int main(void) {
    double r = 2.0;
    printf("%s\n", GREETING);
    printf("Area of r=%.1f: %.4f\n", r, PI * r * r);
    printf("Capacity: %d users\n", MAX_USERS);
    return 0;
}

Đây không phải là biến. Trước khi trình biên dịch chạy, bộ tiền xử lý thay mọi chỗ xuất hiện PI trong mã nguồn bằng các ký tự 3.14159265358979. Trình biên dịch không bao giờ thấy cái tên đó, và đó chính là lý do #define không có kiểu và không xuất hiện trong trình gỡ lỗi.

Lưu ý là không có dấu chấm phẩy và không có =. Macro là văn bản thô, nên lỗi phổ biến này:

#define MAX_USERS 100;        /* note the semicolon */

int limit = MAX_USERS + 1;    /* expands to: int limit = 100; + 1;  -> error */

gây ra lỗi ở một dòng trông chẳng liên quan gì đến định nghĩa. Quy ước đặt tên macro bằng chữ in hoa tồn tại chính là để người đọc biết đang có một phép thay thế diễn ra.

Theo quy ước, macro được viết dạng UPPER_CASE; các biến const cũng thường theo cách này khi chúng đại diện cho cùng một ý tưởng.

Hằng enum

Dạng thứ ba cho bạn một tập hợp số nguyên có tên:

#include <stdio.h>

enum { MAX_USERS = 100, BUFFER_SIZE = 256 };

enum Weekday { MON, TUE, WED, THU, FRI };

int main(void) {
    char buffer[BUFFER_SIZE];   /* a genuine compile-time constant */

    printf("buffer holds %zu bytes\n", sizeof(buffer));
    printf("MAX_USERS = %d\n", MAX_USERS);

    enum Weekday today = WED;
    printf("MON=%d TUE=%d WED=%d, today=%d\n", MON, TUE, WED, today);
    return 0;
}

Giá trị bắt đầu từ 0 và tăng dần một đơn vị nếu bạn không tự gán, nên MON là 0 và FRI là 4. Một enum { ... } không tên là cách viết quen thuộc cho các hằng số nguyên đơn giản.

Hằng enum có một lợi thế thật sự so với cả hai cách còn lại: chúng là hằng số nguyên lúc biên dịch mà trình biên dịch hiểu, và trình gỡ lỗi nhìn thấy được chúng. Toàn bộ chi tiết có trong bài enum trong C.

Nên dùng cách nào

Mặc định nên là const. Dùng #define khi giá trị phải tồn tại trước khi biên dịch, và enum khi bạn cần một số nguyên lúc biên dịch hoặc một nhóm có tên.

Chỗ duy nhất điều này thực sự gây rắc rối là kích thước mảng:

#include <stdio.h>

#define DEFINED_SIZE 5
enum { ENUM_SIZE = 5 };

int global_a[DEFINED_SIZE];   /* fine */
int global_b[ENUM_SIZE];      /* fine */

int main(void) {
    const int const_size = 5;
    int local[const_size];    /* C99 variable-length array - works here... */

    for (int i = 0; i < const_size; i++) local[i] = i * i;
    printf("local[4] = %d\n", local[4]);
    printf("globals: %zu %zu\n", sizeof(global_a), sizeof(global_b));
    return 0;
}

Trong C, một const int là một biến chỉ đọc, không phải biểu thức hằng lúc biên dịch. Bên trong hàm, C99 chấp nhận int local[const_size] bằng cách biến nó thành mảng có độ dài thay đổi; ở phạm vi tệp, trong một struct hoặc làm nhãn case thì nó bị từ chối thẳng. enum và #define dùng được ở mọi nơi.

(Đây là một trong những khác biệt thật sự so với C++, nơi const int là một biểu thức hằng. Code chuyển qua lại giữa hai ngôn ngữ hay vấp phải điểm này.)

const với con trỏ

const và con trỏ kết hợp theo ba cách, và ý nghĩa của chúng không thay thế cho nhau được. Hãy đọc khai báo từ tên biến ra ngoài:

const char *p;          /* p points at chars that must not be modified */
char * const q;         /* q itself cannot be re-pointed; the chars can change */
const char * const r;   /* neither the pointer nor the chars can change */

#include <stdio.h>

int main(void) {
    char text[] = "hello";

    const char *p = text;
    /* *p = 'H';  <- error: the data is const through p */
    p = "world";  /* but re-pointing p is fine */
    printf("p now points at: %s\n", p);

    char * const q = text;
    q[0] = 'H';   /* modifying the data through q is fine */
    /* q = "world";  <- error: q itself is const */
    printf("text is now: %s\n", text);
    return 0;
}

Dạng const char * là dạng bạn sẽ viết nhiều nhất, vì đó là kiểu đúng cho một tham số hàm chỉ đọc chuỗi mà không thay đổi nó:

#include <stdio.h>

/* The const promises the caller: this function will not modify your string. */
size_t count_vowels(const char *s) {
    size_t n = 0;
    for (size_t i = 0; s[i] != '\0'; i++) {
        char c = s[i];
        if (c=='a'||c=='e'||c=='i'||c=='o'||c=='u') n++;
    }
    return n;
}

int main(void) {
    printf("vowels in \"programming\": %zu\n", count_vowels("programming"));
    return 0;
}

Thêm const vào một tham số chỉ đọc không tốn gì và ghi rõ cam kết theo cách mà trình biên dịch buộc tuân theo. Nên làm điều này ở mọi nơi.

Chuỗi ký tự literal thực chất là const

Một cái bẫy tinh vi mà const sinh ra để bắt:

char *s = "hello";   /* legal C, but s points into read-only memory */
s[0] = 'H';          /* undefined behavior - usually a crash */

Chuỗi literal nằm trong một vùng chỉ đọc của tệp thực thi. Ghi qua con trỏ đó thường gây segfault. Khai báo con trỏ là const char *s = "hello"; khiến trình biên dịch từ chối lệnh gán thay vì để chương trình sập lúc chạy.

Nếu cần một chuỗi có thể sửa, hãy sao chép nó vào một mảng:

#include <stdio.h>

int main(void) {
    const char *literal = "hello";   /* read-only, cannot be modified */
    char copy[] = "hello";           /* an array: a private, modifiable copy */

    copy[0] = 'H';
    printf("literal: %s\n", literal);
    printf("copy:    %s\n", copy);
    return 0;
}