Bài 12.518 phút đọc

Con trỏ và hàm

Sau bài này bạn sẽ làm được

Viết hàm nhận con trỏ để sửa dữ liệu của người gọi
Biết khi nào trả về con trỏ là an toàn
Nhận ra con trỏ treo do trả về địa chỉ biến cục bộ
Đặt quy ước rõ ràng về ai sở hữu vùng nhớ

Con trỏ mở ra hai khả năng mà hàm C bình thường không có: sửa được dữ liệu của người gọi, và làm việc với dữ liệu lớn mà không phải sao chép. Đổi lại, nó mang tới một câu hỏi mới mà bạn phải trả lời cho mọi hàm: khi hàm kết thúc, vùng nhớ đó còn sống không.

#Truyền con trỏ vào hàm

truyen.c

#include <stdio.h>

void tang(int *p)
{
    if (p == NULL) return;

    *p += 1;
}

int main(void)
{
    int n = 41;

    tang(&n);
    printf("%d\n", n);      /* 42 */

    return 0;
}

Bài 8.7 đã nói kỹ: C luôn truyền theo giá trị, kể cả ở đây. Bản thân con trỏ p là bản sao của &n. Thứ được chia sẻ là ô nhớ mà nó trỏ tới, không phải bản thân con trỏ.

void thu(int *p)
{
    p = NULL;         /* chỉ đổi bản sao trong hàm, q của người gọi không đổi */

    /* Nếu bỏ dòng trên và viết *p = 1; thì mới sửa được dữ liệu của người gọi.
       Nhưng viết *p = 1; NGAY SAU dòng trên là giải tham chiếu con trỏ rỗng. */
}

int  n = 5;
int *q = &n;

thu(q);
printf("%p\n", (void *)q);   /* vẫn là địa chỉ của n */

Ba dạng tham số con trỏ và ý nghĩa của chúng

Nguyên mẫu	Hàm được phép	Người gọi nên hiểu
void f(const int *p)	Chỉ đọc	Dữ liệu của tôi an toàn
void f(int *p)	Đọc và ghi	Hàm có thể sửa dữ liệu của tôi
void f(int **pp)	Đổi cả con trỏ của người gọi	Biến con trỏ của tôi cũng có thể đổi

Nhìn nguyên mẫu là biết ngay hàm làm gì với dữ liệu của bạn. Đây là lý do const ở tham số con trỏ không phải chuyện hình thức mà là một phần của tài liệu.

#Tránh sao chép dữ liệu lớn

chi-phi.c

typedef struct {
    double m[100][100];      /* 80 000 byte */
} MaTran;

double tong_1(MaTran m)             /* sao chép 80 KB mỗi lời gọi */
{
    double s = 0.0;

    for (int i = 0; i < 100; ++i)
        for (int j = 0; j < 100; ++j)
            s += m.m[i][j];

    return s;
}

double tong_2(const MaTran *m)      /* sao chép 8 byte */
{
    double s = 0.0;

    for (int i = 0; i < 100; ++i)
        for (int j = 0; j < 100; ++j)
            s += m->m[i][j];

    return s;
}

terminal

# Gọi mỗi hàm một trăm nghìn lần

./chi-phi

truyen theo gia tri : 2.418 s
truyen con tro      : 1.032 s
ti le               : 2.3 lan

Kích thước dữ liệu	Nên truyền thế nào
Tới khoảng 16 byte	Theo giá trị, quy ước gọi hàm đặt gọn vào thanh ghi
Lớn hơn, hàm không sửa	const con trỏ
Lớn hơn, hàm có sửa	Con trỏ không const
Cần bản sao độc lập	Theo giá trị, dù lớn

#Trả về con trỏ

Trả về con trỏ hữu ích nhưng đặt ra câu hỏi vòng đời. Có bốn nguồn gốc cho con trỏ trả về, và chỉ một trong bốn là sai.

Con trỏ trỏ tới	An toàn	Ví dụ
Biến cục bộ của hàm	KHÔNG	return &x; với int x cục bộ
Vùng vừa cấp phát động	Có, nhưng người gọi phải giải phóng	return malloc(n);
Dữ liệu mà người gọi truyền vào	Có	return strchr(s, c);
Biến static hoặc toàn cục	Có, nhưng chỉ có một bản dùng chung	return bo_dem_static;

Trả về địa chỉ biến cục bộ

int *tao_so(void)
{
    int x = 42;

    return &x;      /* x chết ngay khi hàm kết thúc */
}

int *p = tao_so();

printf("%d\n", *p);   /* có thể in 42, có thể in rác, tùy lần chạy */

Ba cách đúng

/* Cách 1: người gọi cấp chỗ, hàm chỉ ghi vào */
void tao_so(int *ra)
{
    *ra = 42;
}

int n;
tao_so(&n);

/* Cách 2: hàm cấp phát, người gọi giải phóng */
int *tao_so(void)
{
    int *p = malloc(sizeof *p);

    if (p != NULL) *p = 42;

    return p;
}

int *p = tao_so();

if (p != NULL) {
    printf("%d\n", *p);
    free(p);
}

/* Cách 3: trả về con trỏ vào dữ liệu người gọi đã có */
char *tim(char *s, char c)
{
    for (; *s != '\0'; ++s)
        if (*s == c) return s;

    return NULL;
}

terminal

gcc -std=c17 -Wall sai.c -o sai

sai.c:6:12: warning: function returns address of local variable [-Wreturn-local-addr]

Vì sao lỗi này đặc biệt khó chịu

ngau-nhien.c

int *sai(void)
{
    int x = 42;

    return &x;
}

void pha(void)
{
    int a = 999, b = 888, c = 777;

    (void)a; (void)b; (void)c;
}

int main(void)
{
    int *p = sai();

    printf("%d\n", *p);      /* thường in 42, vì khung chưa bị ghi đè */

    pha();

    printf("%d\n", *p);      /* giờ in rác, vì pha() đã dùng lại khung đó */

    return 0;
}

terminal

./ngau-nhien

42
999

Lần in đầu ra đúng vì khung ngăn xếp của sai vừa bị thu hồi nhưng chưa ai ghi đè lên. Bạn thử, thấy chạy đúng, và tin rằng cách viết đó ổn. Rồi tới lần gọi hàm khác, giá trị đổi. Bài 8.4 đã vẽ sơ đồ khung ngăn xếp giải thích đúng cơ chế này.

Trường hợp mảng static là ngoại lệ

/* Mảng static sống suốt chương trình nên trả về địa chỉ của nó là hợp lệ. */
const char *thu_trong_tuan(int n)
{
    static const char *ten[] = {
        "Chu nhat", "Thu hai", "Thu ba", "Thu tu",
        "Thu nam", "Thu sau", "Thu bay",
    };

    return (n >= 0 && n < 7) ? ten[n] : NULL;
}

Nhưng nhớ cái bẫy ở Bài 8.9: nếu hàm ghi vào bộ đệm static rồi trả về nó, hai lời gọi liên tiếp sẽ giẫm lên nhau. Chỉ dùng cách này khi dữ liệu là hằng.

#Quy tắc vàng về vòng đời

Quy tắc vàng

Con trỏ chỉ hợp lệ trong khoảng thời gian mà đối tượng nó trỏ tới còn sống. Trước khi trả về hay lưu lại một con trỏ, luôn hỏi: khi nào vùng nhớ này chết.

Đối tượng	Sống từ khi nào tới khi nào
Biến cục bộ	Từ khi vào khối tới khi ra khỏi khối
Tham số hàm	Từ khi vào hàm tới khi hàm kết thúc
Biến static hoặc toàn cục	Suốt chương trình
Hằng chuỗi	Suốt chương trình
Vùng cấp phát động	Từ malloc tới free, do bạn quyết định

vong-doi.c

int *p;

{
    int x = 42;

    p = &x;
}                    /* x chết ở đây, p thành con trỏ treo */

printf("%d\n", *p);  /* hành vi không xác định */

/* Cùng vấn đề với vòng lặp */
int *q;

for (int i = 0; i < 3; ++i) {
    int tam = i;

    q = &tam;        /* tam mới mỗi lượt, và chết mỗi lượt */
}

printf("%d\n", *q);  /* hành vi không xác định */

#Ai sở hữu vùng nhớ

Quyền sở hữu

Quy ước cho biết ai có trách nhiệm giải phóng một vùng nhớ. C không có cơ chế nào cho việc này, nên nó hoàn toàn là chuyện tài liệu và kỷ luật.

Kiểu hàm	Ai giải phóng	Ví dụ trong thư viện chuẩn
Hàm trả về vùng vừa cấp	Người gọi	malloc, strdup, fopen
Hàm trả về con trỏ vào dữ liệu có sẵn	Không ai, vì không cấp gì	strchr, strstr, strtok
Hàm ghi vào bộ đệm người gọi cấp	Người gọi, nhưng bộ đệm của họ	snprintf, fgets, memcpy
Hàm trả về con trỏ tới dữ liệu tĩnh	Không ai, và không được giải phóng	localtime, getenv

Nhầm loại là hai lỗi khác nhau

char *s = strdup("abc");
free(s);                        /* đúng: strdup cấp phát */

char *t = strchr("abc", 'b');
free(t);                        /* SAI: chưa từng cấp phát, chương trình sập */

char *u = getenv("HOME");
free(u);                        /* SAI: dữ liệu thuộc về thư viện */

char *v = strdup("abc");
/* quên free(v); */             /* rò rỉ bộ nhớ */

Ghi quy ước vào tên và vào tài liệu

/* Trả về vùng nhớ mới. Người gọi PHẢI gọi free.
   Trả về NULL nếu không đủ bộ nhớ. */
char *tao_ban_sao(const char *s);

/* Ghi vào bộ đệm do người gọi cấp. Không cấp phát gì.
   Trả về độ dài đáng lẽ cần, giống snprintf. */
size_t dinh_dang(char *ra, size_t co, int n);

/* Trả về con trỏ vào chính chuỗi đầu vào. Không được giải phóng.
   Chỉ hợp lệ khi chuỗi đầu vào còn sống. */
const char *tim_tu(const char *s, const char *tu);

Tự làm thử

Viết hàm nhận con trỏ và sửa giá trị của người gọi, thêm kiểm tra NULL ở đầu hàm.
Viết hàm gán NULL cho tham số con trỏ bên trong, chứng minh con trỏ của người gọi không đổi.
Đo thời gian truyền một struct 80 kilobyte theo giá trị và theo con trỏ, mỗi cách một trăm nghìn lần.
Cài chương trình trả về địa chỉ biến cục bộ, in giá trị trước và sau khi gọi một hàm khác, ghi lại kết quả.
Viết ba phiên bản hàm tạo chuỗi theo ba quy ước sở hữu trong bảng, so sánh mã ở chỗ gọi.
Gọi free lên con trỏ trả về từ strchr và chạy dưới valgrind, đọc thông báo.

Trình chấm điểm tự động sẽ được bổ sung ở giai đoạn sau. Hiện tại bạn tự chạy thử trên máy.

Tóm tắt

Truyền con trỏ cho phép hàm sửa dữ liệu của người gọi, nhưng bản thân con trỏ vẫn là bản sao.
Dữ liệu lớn hơn khoảng mười sáu byte nên truyền bằng con trỏ, kèm const nếu hàm không sửa.
Không bao giờ trả về địa chỉ biến cục bộ. Lỗi này thường cho kết quả đúng ở lần thử đầu tiên.
Con trỏ chỉ hợp lệ trong khoảng thời gian đối tượng nó trỏ tới còn sống.
Mỗi hàm trả về con trỏ phải ghi rõ ai sở hữu vùng nhớ đó và ai có trách nhiệm giải phóng.