Con trỏ tới struct trong C: toán tử mũi tên và struct trên heap

Một struct truyền vào hàm sẽ bị sao chép. Với một điểm gồm hai số int thì không sao, nhưng với một bản ghi 200 byte thì lãng phí, và còn khiến việc sửa đổi là không thể, vì hàm chỉ thấy bản sao của riêng nó. Trỏ tới struct giải quyết cả hai vấn đề cùng lúc, và đây cũng là cách duy nhất để xây dựng các cấu trúc có thể lớn dần: danh sách, cây, đồ thị.

Lấy con trỏ tới một struct

Không cần gì đặc biệt. & cho bạn địa chỉ, và kiểu dữ liệu là "con trỏ tới struct":

#include <stdio.h>

struct Point {
    int x;
    int y;
};

int main(void) {
    struct Point p = {3, 4};
    struct Point *ptr = &p;

    printf("x via struct : %d\n", p.x);
    printf("x via pointer: %d\n", (*ptr).x);
    printf("x via arrow  : %d\n", ptr->x);
    return 0;
}

Cả ba dòng đều in ra 3. Hai dòng cuối là cùng một thao tác được viết theo hai cách.

Vì sao (*ptr).x cần dấu ngoặc

Bạn có thể thử bỏ ngoặc và viết *ptr.x. Khi đó code được biên dịch thành một thứ hoàn toàn khác, hoặc thường gặp hơn là không biên dịch được, vì toán tử (operator) thành viên . có độ ưu tiên cao hơn toán tử giải tham chiếu *:

*ptr.x        // parses as *(ptr.x)  -- wrong
(*ptr).x      // dereference first, then take the member -- correct
ptr->x        // the same thing, said shortly

ptr.x đòi một thành viên của con trỏ, mà con trỏ thì không có thành viên nào. Thông báo lỗi của trình biên dịch ("request for member 'x' in something not a structure or union") thực ra là một bug về độ ưu tiên đội lốt.

Vì dạng có ngoặc vừa xấu vừa dễ viết sai, C cung cấp ->. Trong thực tế bạn gần như sẽ không bao giờ thấy (*p).x trong code thật; cứ dùng p->x và quên dạng dài đi, ngoại trừ khi cần giải thích mũi tên có nghĩa là gì.

Truyền struct bằng con trỏ

Tham số con trỏ đưa cho hàm chính struct thật của nơi gọi, nên các thay đổi được giữ lại:

#include <stdio.h>

struct Point {
    int x;
    int y;
};

/* Mutates the caller's struct. */
void translate(struct Point *p, int dx, int dy) {
    p->x += dx;
    p->y += dy;
}

/* Reads only - const says so, and the compiler enforces it. */
void print_point(const struct Point *p) {
    printf("(%d, %d)\n", p->x, p->y);
}

int main(void) {
    struct Point p = {3, 4};

    print_point(&p);
    translate(&p, 10, -2);
    print_point(&p);
    return 0;
}

Hai thói quen nên hình thành ở đây:

• Đánh dấu con trỏ chỉ đọc là const. const struct Point *p cam kết hàm sẽ không thay đổi thứ mà p trỏ tới. Nếu sau này ai đó thêm p->x = 0 vào bên trong, việc biên dịch sẽ thất bại thay vì bug lọt ra ngoài. Nó cũng thể hiện rõ ý định ngay tại chỗ gọi.
• Truyền con trỏ với struct lớn, kể cả khi chỉ đọc. Một struct có buffer tên 64 byte tốn 64 byte sao chép mỗi lần gọi theo giá trị; một con trỏ chỉ tốn 8.

Struct nhỏ vẫn có thể truyền theo giá trị: struct Point với 8 byte sao chép rẻ như một con trỏ, và bản truyền theo giá trị không thể là NULL, loại bỏ hẳn một kiểu lỗi.

Con trỏ vào mảng struct

Phép toán con trỏ trên mảng struct hoạt động giống hệt như trên mảng int: p + 1 tiến lên đúng một struct, tính cả phần đệm.

#include <stdio.h>

struct Employee {
    int id;
    char name[16];
    double salary;
};

double total_payroll(const struct Employee *staff, int n) {
    double total = 0.0;
    for (const struct Employee *e = staff; e < staff + n; e++) {
        total += e->salary;
    }
    return total;
}

int main(void) {
    struct Employee staff[] = {
        {101, "Ada",   92000.0},
        {102, "Grace", 105000.0},
        {103, "Alan",  87000.0},
    };
    int n = sizeof(staff) / sizeof(staff[0]);

    printf("Payroll: %.2f\n", total_payroll(staff, n));
    return 0;
}

Tên mảng suy biến thành con trỏ tới phần tử đầu tiên, nên tại chỗ gọi staff đã là một struct Employee *. Đó cũng là lý do hàm cần nhận n riêng: sizeof bên trong hàm sẽ đo con trỏ chứ không đo mảng.

Cấp phát struct trên heap

Struct trên stack biến mất khi kết thúc phạm vi (scope) của nó. Để tạo một struct sống lâu hơn hàm đã tạo ra nó, hoặc để tạo bao nhiêu struct tùy theo đầu vào, hãy cấp phát bằng malloc:

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

struct Employee {
    int id;
    char name[16];
    double salary;
};

struct Employee *make_employee(int id, const char *name, double salary) {
    struct Employee *e = malloc(sizeof *e);
    if (e == NULL) {
        return NULL;            /* out of memory - the caller must check */
    }
    e->id = id;
    snprintf(e->name, sizeof e->name, "%s", name);
    e->salary = salary;
    return e;
}

int main(void) {
    struct Employee *e = make_employee(101, "Ada", 92000.0);
    if (e == NULL) {
        fprintf(stderr, "allocation failed\n");
        return 1;
    }

    printf("%d %s %.2f\n", e->id, e->name, e->salary);

    free(e);
    return 0;
}

Bốn chi tiết trong hàm nhỏ đó đều quan trọng:

• sizeof *e, không phải sizeof(struct Employee). Nó có nghĩa là "kích thước của thứ mà e trỏ tới", nên nếu kiểu dữ liệu thay đổi thì phần cấp phát tự động theo kịp. Hai thứ không thể lệch nhau.
• Kiểm tra NULL. malloc trả về NULL khi không đáp ứng được yêu cầu. Ghi e->id qua con trỏ null là một lỗi segmentation fault.
• Khởi tạo mọi thành viên. malloc không xóa vùng nhớ về 0; struct nhận về chứa đầy giá trị rác. (calloc(1, sizeof *e) sẽ đặt về 0 cho bạn.)
• Phải có người gọi free. Trả về một con trỏ đã cấp phát nghĩa là chuyển trách nhiệm đó cho nơi gọi. Hãy ghi rõ trong chú thích: quy tắc sở hữu không rõ ràng chính là khởi đầu của rò rỉ bộ nhớ.

Thành quả: một nút danh sách liên kết

Đây là điều struct không làm được nếu thiếu con trỏ. Một struct không thể chứa chính nó, vì như vậy nó sẽ lớn vô hạn, nhưng nó có thể chứa một con trỏ tới struct cùng loại, và chỉ một mẹo đó đủ để xây dựng mọi cấu trúc dữ liệu liên kết trong C.

#include <stdio.h>
#include <stdlib.h>

struct Node {
    int value;
    struct Node *next;     /* a pointer to the same type is fine */
};

/* Adds a node to the front and returns the new head. */
struct Node *push(struct Node *head, int value) {
    struct Node *n = malloc(sizeof *n);
    if (n == NULL) {
        return head;       /* out of memory: list is unchanged */
    }
    n->value = value;
    n->next = head;
    return n;
}

void print_list(const struct Node *head) {
    for (const struct Node *n = head; n != NULL; n = n->next) {
        printf("%d -> ", n->value);
    }
    printf("NULL\n");
}

void free_list(struct Node *head) {
    while (head != NULL) {
        struct Node *next = head->next;   /* save before freeing */
        free(head);
        head = next;
    }
}

int main(void) {
    struct Node *head = NULL;

    head = push(head, 3);
    head = push(head, 2);
    head = push(head, 1);

    print_list(head);
    free_list(head);
    return 0;
}

Chú ý rằng struct Node *next; tham chiếu tới struct Node khi struct Node vẫn đang được khai báo. Điều này hợp lệ chính vì con trỏ có kích thước xác định bất kể nó trỏ tới đâu, nên trình biên dịch chưa cần định nghĩa đầy đủ. Đây cũng là chỗ duy nhất bạn bắt buộc phải dùng tag struct Node ngay cả khi đã viết typedef: tên typedef chưa tồn tại bên trong chính định nghĩa của nó.

Vòng lặp free_list lưu lại head->next trước khi gọi free(head). Đọc head->next sau khi free là lỗi use-after-free: vùng nhớ đó không còn là của bạn, và giá trị bạn đọc được là bất cứ thứ gì bộ cấp phát đã ghi vào.

Lỗi thường gặp

• p->x trên con trỏ chưa khởi tạo hoặc NULL. Nguyên nhân crash phổ biến nhất trong code dùng nhiều struct. Hãy khởi tạo con trỏ bằng NULL và kiểm tra trước khi giải tham chiếu.
• Trả về con trỏ tới struct cục bộ. struct Point *bad(void) { struct Point p = {1,2}; return &p; } trả về địa chỉ của vùng nhớ không còn tồn tại ngay khi hàm trả về. Hãy trả về struct theo giá trị, hoặc cấp phát nó.
• Free hai lần, hoặc quên free. Mỗi malloc đi cặp với đúng một free. Sau khi free, hãy gán con trỏ bằng NULL để một lần vô tình dùng lại sau đó crash rõ ràng thay vì âm thầm làm hỏng bộ nhớ.
• Sao chép struct có chứa con trỏ. Phép gán struct sao chép giá trị con trỏ chứ không sao chép thứ nó trỏ tới. Lúc này cả hai struct cùng tham chiếu một buffer, và struct nào free nó trước sẽ khiến struct kia thành con trỏ treo.