Con trỏ và mảng trong C: decay, arr[i] = *(arr+i) và bẫy sizeof

Mảng và con trỏ trong C là hai thứ khác nhau nhưng phần lớn thời gian lại hoạt động giống nhau. Chính cái "phần lớn thời gian" đó khiến chủ đề này dễ trượt chân: code coi mảng như con trỏ thường vẫn chạy, cho đến ngày nó rơi vào một trong hai chỗ mà sự khác biệt có ý nghĩa và kết quả âm thầm sai.

Bài này vạch rõ ranh giới đó.

Mảng suy biến: một quy tắc đứng sau mọi thứ

Trong gần như mọi biểu thức, tên mảng tự động được chuyển thành con trỏ tới phần tử đầu tiên. Hiện tượng này gọi là suy biến (decay). arr trở thành &arr[0], với kiểu int *.

#include <stdio.h>

int main(void) {
    int arr[4] = {10, 20, 30, 40};

    printf("arr      = %p\n", (void *)arr);       // decays to &arr[0]
    printf("&arr[0]  = %p\n", (void *)&arr[0]);   // the same address
    printf("*arr     = %d\n", *arr);              // 10, the first element

    int *p = arr;                                  // no & needed - decay does it
    printf("*p       = %d\n", *p);

    return 0;
}

Tên mảng và địa chỉ phần tử đầu tiên in ra giống hệt nhau. Đó là sự suy biến đang diễn ra, và cũng là lý do bạn có thể gán mảng cho một con trỏ mà không cần &.

Có đúng ba chỗ sự suy biến không xảy ra: khi là toán hạng của sizeof, khi là toán hạng của &, và khi khởi tạo một mảng ký tự từ một chuỗi hằng. Ở mọi chỗ khác, hãy coi như mảng đã suy biến.

arr[i] chính là *(arr + i)

Chuẩn C định nghĩa toán tử chỉ số dựa trên số học con trỏ: a[b] nghĩa là *(a + b). Truy cập theo chỉ số không phải một tính năng riêng, mà chỉ là cách viết tắt.

#include <stdio.h>

int main(void) {
    int arr[5] = {1, 2, 3, 4, 5};

    for (int i = 0; i < 5; i++) {
        printf("arr[%d] = %d   *(arr + %d) = %d\n",
               i, arr[i], i, *(arr + i));
    }

    int *p = arr;
    printf("\np[2] = %d  (a pointer can be subscripted too)\n", p[2]);
    printf("2[arr] = %d  (legal, because addition commutes)\n", 2[arr]);

    return 0;
}

Từ đó rút ra hai hệ quả. Thứ nhất, con trỏ cũng dùng được chỉ số: p[2] là *(p + 2), nên các hàm nhận con trỏ vẫn dùng được cú pháp arr[i] quen thuộc. Thứ hai, 2[arr] vẫn biên dịch được: *(2 + arr) là cùng địa chỉ với *(arr + 2). Ngoài các bài đố ra thì chẳng ai viết như vậy, nhưng nó trả lời dứt khoát câu hỏi truy cập theo chỉ số có "thực sự" là số học con trỏ hay không.

Truyền mảng vào hàm

Vì có sự suy biến, một hàm không bao giờ nhận được mảng. Nó nhận một con trỏ.

#include <stdio.h>

// these three declarations are IDENTICAL to the compiler
int sum_a(int arr[], int n);
int sum_b(int arr[100], int n);   // the 100 is ignored entirely
int sum_c(int *arr, int n);

int sum_c(int *arr, int n) {
    int total = 0;
    for (int i = 0; i < n; i++) {
        total += arr[i];
    }
    return total;
}

int main(void) {
    int data[6] = {3, 1, 4, 1, 5, 9};
    int n = sizeof data / sizeof data[0];

    printf("n     = %d\n", n);
    printf("sum   = %d\n", sum_c(data, n));

    // works on a slice too - a pointer is just a starting position
    printf("tail  = %d\n", sum_c(data + 3, 3));

    return 0;
}

Có ba điều đáng rút ra từ ví dụ trên.

Kích thước trong int arr[100] chỉ để làm tài liệu, không hơn. Trình biên dịch viết lại tham số thành int *arr và không bao giờ kiểm tra bạn có truyền vào đủ 100 phần tử hay không.

Độ dài phải được truyền riêng. Hàm có một địa chỉ nhưng không biết dữ liệu kéo dài tới đâu. Đó là lý do gần như mọi hàm C nhận mảng đều nhận thêm một số lượng: memcpy(dst, src, n), fread(ptr, size, count, f), qsort(base, nmemb, size, cmp). Chuỗi là ngoại lệ chỉ vì chúng tự mang theo dấu kết thúc của mình, ký tự '\0'.

Truyền con trỏ thì rẻ và dữ liệu được dùng chung. Không có bản sao nào của mảng được tạo ra, nên hàm có thể sửa các phần tử của bên gọi, và đó thường đúng là điều bạn muốn:

#include <stdio.h>

void double_all(int *arr, int n) {
    for (int i = 0; i < n; i++) {
        arr[i] *= 2;
    }
}

void print_all(const int *arr, int n) {   // const: promises not to modify
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
}

int main(void) {
    int values[5] = {1, 2, 3, 4, 5};

    print_all(values, 5);
    double_all(values, 5);
    print_all(values, 5);      // the caller's array really changed

    return 0;
}

Hãy đánh dấu các tham số chỉ đọc là const int * như print_all đã làm. Nó ghi rõ ý định và để trình biên dịch bắt được những lần vô tình ghi vào.

Cái bẫy sizeof

Đây là bug mà lập trình viên C nào cũng dính một lần. sizeof là một trong hai chỗ sự suy biến không xảy ra, nên nó cho kích thước thật của mảng ở nơi mảng được khai báo, và cho kích thước của một con trỏ ở bất kỳ đâu mảng đã suy biến.

#include <stdio.h>

void inspect(int arr[]) {
    printf("inside function: sizeof(arr) = %zu\n", sizeof arr);
    printf("inside function: computed length = %zu  <-- WRONG\n",
           sizeof arr / sizeof arr[0]);
}

int main(void) {
    int data[10] = {0};

    printf("in main: sizeof(data) = %zu\n", sizeof data);
    printf("in main: length = %zu  <-- correct\n",
           sizeof data / sizeof data[0]);

    inspect(data);
    return 0;
}

Trong main, sizeof data là 40 byte và độ dài tính ra bằng 10. Bên trong inspect, sizeof arr là kích thước một con trỏ, tức 8 trên máy 64 bit, và "độ dài" tính ra bằng 2. Code trông giống hệt nhau nhưng lại sai một cách lặng lẽ.

Quy tắc rút ra: chỉ tính độ dài mảng trong phạm vi nơi mảng được khai báo, rồi truyền giá trị đó đi tiếp từ đó.

& của một mảng có kiểu khác

Chỗ còn lại mà sự suy biến không xảy ra là toán tử &. &arr là con trỏ tới toàn bộ mảng, không phải tới phần tử đầu tiên. Cả hai giữ cùng một địa chỉ; khác biệt nằm ở ý nghĩa của "cộng 1".

#include <stdio.h>

int main(void) {
    int arr[5] = {1, 2, 3, 4, 5};

    printf("arr      = %p   arr + 1  = %p\n",
           (void *)arr, (void *)(arr + 1));      // steps 4 bytes (one int)
    printf("&arr     = %p   &arr + 1 = %p\n",
           (void *)&arr, (void *)(&arr + 1));    // steps 20 bytes (the array)

    return 0;
}

Cùng địa chỉ xuất phát, khác bước nhảy. arr có kiểu int * và bước đi một phần tử; &arr có kiểu int (*)[5] và bước đi cả mảng. Đây là cơ chế giúp truyền một hàng của mảng 2 chiều hoạt động được, được giải thích trong bài mảng nhiều chiều.

Con trỏ tới mảng và mảng con trỏ

Hai khai báo trông na ná nhau nhưng mang nghĩa trái ngược:

int *p[5];     // array of 5 pointers to int
int (*q)[5];   // pointer to an array of 5 ints

[] có độ ưu tiên cao hơn *, nên int *p[5] được hiểu là "p là một mảng, gồm các con trỏ". Cặp ngoặc trong int (*q)[5] buộc * gắn trước: "q là một con trỏ, tới một mảng".

int *p[5]                     int (*q)[5]

 p[0] -> [ int ]               q -> [ int | int | int | int | int ]
 p[1] -> [ int ]                     one contiguous block of 5
 p[2] -> [ int ]
 p[3] -> [ int ]
 p[4] -> [ int ]
 five separate addresses

Mảng con trỏ là loại phổ biến, và bạn đã từng dùng nó: char *argv[] là một mảng các con trỏ tới chuỗi, mỗi con trỏ ứng với một đối số dòng lệnh. Đó cũng là cách lưu một danh sách chuỗi có độ dài khác nhau mà không lãng phí bộ nhớ.

#include <stdio.h>

int main(void) {
    // array of pointers: each entry points to a string of its own length
    const char *days[] = {"Monday", "Tuesday", "Wednesday"};
    int n = sizeof days / sizeof days[0];

    for (int i = 0; i < n; i++) {
        printf("%d: %s\n", i, days[i]);
    }

    // pointer to an array of 5 ints
    int block[5] = {1, 2, 3, 4, 5};
    int (*q)[5] = &block;

    printf("via q: %d %d\n", (*q)[0], (*q)[4]);
    printf("sizeof(*q) = %zu bytes (the whole array)\n", sizeof *q);

    return 0;
}

Lưu ý (*q)[0]: dereference con trỏ để lấy mảng, rồi truy cập theo chỉ số. Cặp ngoặc lại là bắt buộc, vì cùng lý do độ ưu tiên.

Những chỗ mảng và con trỏ thực sự khác nhau

Nhớ bảng ngắn này là hết nhầm lẫn:

Tên mảng không phải một biến giữ địa chỉ: nó chính là vùng lưu trữ, còn địa chỉ được tính ra khi cần. Đó là lý do bạn không thể gán cho nó.