Bài 30.124 phút đọc

Con trỏ void và cái giá của nó

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

Dùng con trỏ void làm kiểu chung cho mọi con trỏ dữ liệu
Viết hàm hoán đổi tổng quát bằng byte
Nêu bốn thứ mất đi khi xóa kiểu
Nhận ra vấn đề thẳng hàng khi cấp phát vùng chung

Chương 29 hoãn quyết định gọi hàm nào. Chương này hoãn quyết định xử lý kiểu nào. Công cụ duy nhất C cho bạn là con trỏ không kiểu, và nó mạnh đúng bằng mức nó nguy hiểm.

#Con trỏ void là gì

Con trỏ void

Con trỏ tới một vùng nhớ mà trình biên dịch không biết chứa gì. Nó giữ được địa chỉ của bất kỳ đối tượng nào, và mọi con trỏ dữ liệu chuyển qua lại với nó được mà không mất thông tin.

void *p;

int x = 5;
p = &x;                     /* KHONG can ep kieu trong C */

printf("%d\n", *(int *)p);  /* PHAI ep kieu truoc khi giai tham chieu */

double d = 1.5;
p = &d;                     /* cung con tro do, gio tro toi double */

Thao tác	Hợp lệ	Ghi chú
Gán con trỏ bất kỳ vào void *	Có	Không cần ép kiểu trong C, khác C++
Gán void * vào con trỏ khác	Có	Cũng không cần ép, nhưng nên ép cho rõ
*p	Không	Không biết đọc bao nhiêu byte
p[0]	Không	Cùng lý do
p + 1	Không chuẩn	GCC cho phép và coi như char *, nhưng đó là mở rộng
sizeof(void)	Không chuẩn	GCC trả 1, chuẩn thì cấm
p == NULL	Có	So sánh bình thường
memcpy(p, q, n)	Có	Mọi hàm nhận void * đều dùng được

Số học con trỏ trên void * không phải chuẩn

void *p = mang;

p = p + 1;              /* MO RONG GNU: coi void nhu 1 byte
                           gcc -std=c11 -pedantic bao:
                           warning: pointer of type 'void *' used in arithmetic */

p = (char *)p + 1;      /* dung: ep sang char * roi cong */

terminal

gcc -std=c11 -Wall -Wextra -pedantic -c void-arith.c

void-arith.c:5:9: warning: pointer of type 'void *' used in arithmetic [-Wpointer-arith]
    5 |     p = p + 1;
      |         ^

Con trỏ hàm không thuộc nhóm này

void *p = (void *)mot_ham;      /* KHONG kha chuyen, xem Bai 29.1 */

/* Chuan chi bao dam void * chua duoc moi con tro DU LIEU.
   Con tro ham la mot ho khac han. */

#Hoán đổi tổng quát

Một hàm cho mỗi kiểu

void hoan_doi_int(int *a, int *b)          { int t = *a; *a = *b; *b = t; }
void hoan_doi_double(double *a, double *b) { double t = *a; *a = *b; *b = t; }
void hoan_doi_sv(SV *a, SV *b)             { SV t = *a; *a = *b; *b = t; }

/* Mot ham cho moi kieu, va ban khong bao gio viet du. */

Một hàm, làm việc trên byte

#include <stddef.h>

void hoan_doi(void *a, void *b, size_t co) {
    unsigned char *pa = a, *pb = b;

    for (size_t i = 0; i < co; ++i) {
        unsigned char t = pa[i];

        pa[i] = pb[i];
        pb[i] = t;
    }
}

int x = 1, y = 2;                hoan_doi(&x, &y, sizeof x);
double u = 1.5, v = 2.5;         hoan_doi(&u, &v, sizeof u);
SV a = {"An", 20}, b = {"Binh", 21};  hoan_doi(&a, &b, sizeof a);

terminal

gcc -std=c11 -Wall -Wextra -o hoan-doi hoan-doi.c && ./hoan-doi

int:    2 1
double: 2.5 1.5
struct: Binh 21 | An 20

Vì sao unsigned char chứ không phải char

unsigned char *pa = a;

/* Chuan C cho phep truy cap MOI doi tuong qua con tro toi
   character type, va do la ngoai le duy nhat cua quy tac
   bi danh nghiem ngat. Ba kieu duoc phep:

     char, signed char, unsigned char

   Chon unsigned char vi:
     - khong co bit dau, moi gia tri byte deu bieu dien duoc
     - khong co bieu dien bay, nen doc byte bat ky luon hop le
     - y dinh ro rang: day la BYTE THO, khong phai ky tu

   Tu C23 co them kieu chuyen dung: unsigned char van la chuan,
   nhung memcpy va bo ban cua no van la cach nhanh nhat. */

Hoán đổi một biến với chính nó vẫn đúng

terminal

./hoan-doi --tu-doi

hoan doi z voi chinh no: z = 7

/* Vong lap tren doi tung byte:
     t = pa[i];  pa[i] = pb[i];  pb[i] = t;

   Neu pa == pb thi:
     t = pa[i];  pa[i] = pa[i];  pa[i] = t;
   -> gia tri khong doi. An toan.

   Nguoc lai voi thu thuat XOR ma Bai 31.5 se noi: */

a ^= b; b ^= a; a ^= b;        /* SAI khi a va b cung dia chi:
                                  a ^= a  ->  a = 0, mat gia tri */

Nhưng nó chậm hơn hẳn bản có kiểu

/* Ban co kieu, voi -O2: */
int t = *a; *a = *b; *b = t;

/* gcc sinh ra ba lenh mov, hoac tham chi hai lenh xchg. */

/* Ban tong quat, voi sizeof = 4: */
for (size_t i = 0; i < 4; ++i) { ... }

/* gcc thuong mo duoc vong lap khi co la HANG SO biet luc bien dich,
   nhung neu co la mot bien thi khong the, va ban tra gia:
     - mot vong lap that
     - bon lan doc, bon lan ghi, tung byte mot
     - khong dung duoc lenh SIMD

   Do la ly do Bai 30.2 gioi thieu cach macro sinh ma. */

/* Neu chi can hoan doi va co bo nho tam: */
void hoan_doi_nhanh(void *a, void *b, size_t co) {
    unsigned char tam[64];

    if (co <= sizeof tam) {
        memcpy(tam, a,   co);
        memcpy(a,   b,   co);
        memcpy(b,   tam, co);

        return;
    }

    /* ... roi ve vong lap tung byte cho truong hop lon ... */
}

/* memcpy duoc trinh bien dich noi tuyen va vector hoa,
   nen cach nay nhanh hon vong lap tung byte nhieu lan. */

#Bốn thứ bạn mất

Mất gì	Cụ thể	Hậu quả
Kiểm kiểu	Trình biên dịch không so được kiểu nữa	Truyền nhầm kiểu vẫn dịch sạch, sai lúc chạy
Kích thước	Bạn phải tự truyền sizeof	Truyền sai kích thước là đọc ghi ngoài vùng
Tối ưu	Trình biên dịch không biết bố cục nên không vector hóa	Chậm hơn bản có kiểu vài lần
Khả năng đọc	Đọc mã không biết vùng đó chứa gì	Người bảo trì phải tra tài liệu

Ba cách gọi sai mà trình biên dịch không bắt được

int    x = 1;
double d = 2.0;

hoan_doi(&x, &d, sizeof x);      /* KIEU KHAC NHAU: doi 4 byte dau
                                    cua d voi x. d thanh rac. */

hoan_doi(&x, &d, sizeof d);      /* KICH THUOC SAI: doc ghi 8 byte
                                    tai &x, ma x chi co 4.
                                    TRAN NGAN XEP. */

int a[10], b[10];
hoan_doi(a, b, 10);              /* QUEN sizeof: chi doi 10 BYTE
                                    thay vi 40. */

/* Ca ba deu bien dich SACH voi -Wall -Wextra -Wpedantic. */

Ba cách giảm rủi ro mà vẫn giữ tính tổng quát

/* Cach 1: macro boc lai, tu tinh sizeof */
#define HOAN_DOI(a, b) hoan_doi(&(a), &(b), sizeof (a))

int x = 1, y = 2;
HOAN_DOI(x, y);                  /* khong the quen sizeof nua */

/* Van chua bat duoc kieu khac nhau. Them mot lop nua: */

/* Cach 2: kiem kieu bang _Static_assert va __typeof__ (GNU) */
#define HOAN_DOI2(a, b)                                          \
    do {                                                         \
        _Static_assert(__builtin_types_compatible_p(             \
            __typeof__(a), __typeof__(b)),                       \
            "hai doi so phai cung kieu");                        \
        hoan_doi(&(a), &(b), sizeof (a));                        \
    } while (0)

/* Cach 3: bo han void*, dung macro sinh ma. Bai 30.2. */

Quy tắc: đẩy void * xuống tầng thấp nhất có thể

void * ở giao diện

/* Giao dien cong khai nhan void* */
int ds_them(DanhSach *ds, void *phan_tu);

/* Nguoi dung phai nho kieu, va khong ai kiem ho ho. */

void * chỉ trong cài đặt

/* Ben trong dung void*, nhung giao dien co kieu: */

/* danhsach.h */
typedef struct DanhSach DanhSach;
int ds_them_int(DanhSach *ds, int x);
int ds_them_sv(DanhSach *ds, const SinhVien *sv);

/* danhsach.c */
static int ds_them_tho(DanhSach *ds, const void *p, size_t co);

int ds_them_int(DanhSach *ds, int x) {
    return ds_them_tho(ds, &x, sizeof x);
}

Thư viện chuẩn làm đúng như vậy ở chỗ nó làm được: strcpy nhận char * chứ không nhận void *, còn memcpy thì buộc phải nhận void * vì nó thật sự tổng quát.

#Vấn đề thẳng hàng

Thẳng hàng

Yêu cầu rằng địa chỉ của một đối tượng phải chia hết cho một số nào đó. Trên x86 truy cập lệch hàng chỉ chậm hơn, còn trên nhiều kiến trúc khác thì nó gây lỗi phần cứng.

terminal

./g1 --thang-hang

alignof(char)=1 int=4 double=8 max_align_t=16
sizeof(max_align_t) = 32

Cấp phát một vùng chung rồi cắt ra là chỗ dễ sai

Cắt vùng đệm tùy tiện

unsigned char bo_dem[1024];
size_t vt = 0;

char  *ten = (char *)(bo_dem + vt);  vt += 5;      /* 5 byte */
double *d  = (double *)(bo_dem + vt);              /* dia chi bo_dem + 5 */

*d = 1.5;      /* dia chi khong chia het cho 8.
                  Tren x86: cham hon.
                  Tren ARM cu hoac SPARC: LOI PHAN CUNG.
                  Voi -fsanitize=undefined: bao loi. */

Làm tròn lên trước mỗi lần cắt

#include <stdalign.h>

/* Lam tron len boi so cua a */
static size_t lam_tron(size_t x, size_t a) { return (x + a - 1) / a * a; }

alignas(max_align_t) unsigned char bo_dem[1024];
size_t vt = 0;

char *ten = (char *)(bo_dem + vt);
vt += 5;

vt = lam_tron(vt, alignof(double));     /* 5 -> 8 */

double *d = (double *)(bo_dem + vt);

*d = 1.5;                                /* thang hang, an toan */

terminal

gcc -std=c11 -fsanitize=undefined -o thang-hang thang-hang.c && ./thang-hang

thang-hang.c:12:8: runtime error: store to misaligned address 0x7ffd4c0a1005 for type 'double', which requires 8 byte alignment
0x7ffd4c0a1005: note: pointer points here

malloc luôn trả về địa chỉ thẳng hàng cho mọi kiểu

void *p = malloc(n);

/* Chuan bao dam p thang hang du cho BAT KY kieu co ban nao
   co kich thuoc khong vuot qua n. Trong thuc te malloc luon
   tra ve boi so cua alignof(max_align_t), tuc 16 tren x86-64.

   Nen ban KHONG can lo thang hang khi dung malloc truc tiep.
   Chi khi TU cat mot vung lon thanh nhieu phan thi moi phai lo,
   nhu vi du o tren. */

/* C11 co ham cap phat theo thang hang chi dinh: */
void *aligned_alloc(size_t thang_hang, size_t co);

/* Yeu cau: co phai la boi so cua thang_hang. */
double *d = aligned_alloc(64, 64 * sizeof(double));   /* thang hang 64 byte,
                                                         vua mot dong bo dem */

Vì sao sizeof(max_align_t) là 32 mà alignof chỉ là 16

alignof(max_align_t) = 16
sizeof (max_align_t) = 32

/* max_align_t la mot kieu co YEU CAU THANG HANG lon nhat
   trong so moi kieu co ban. Cai dat thuong dinh nghia no
   la mot union chua long double, long long, va void*.

   Kich thuoc cua no khong co y nghia gi ca, chi co
   alignof moi quan trong. Dung nham sizeof cho ra so lon hon
   can thiet, va lang phi bo nho. */

vt = lam_tron(vt, alignof(max_align_t));    /* dung */
vt = lam_tron(vt, sizeof (max_align_t));    /* thua, nhung khong sai */

Bốn quy tắc khi làm việc với vùng nhớ thô

Dùng unsigned char * để chạy qua byte. Đó là kiểu duy nhất chuẩn cho phép nhìn mọi đối tượng như dãy byte.
Ép sang char * trước khi làm số học. Số học trên void * là mở rộng của GCC.
Làm tròn lên trước mỗi lần cắt vùng. Và dùng alignof chứ đừng đoán con số.
Bật -fsanitize=undefined khi kiểm thử. Nó bắt được lỗi lệch hàng mà x86 vẫn chạy được.

Tự làm thử

Cài hoan_doi tổng quát và dùng nó cho int, double và một struct.
Gọi nó với hai kiểu khác nhau và xác nhận trình biên dịch không cảnh báo gì.
Viết macro HOAN_DOI tự tính sizeof, rồi thêm _Static_assert kiểm hai kiểu giống nhau.
Hoán đổi một biến với chính nó và xác nhận giá trị không đổi.
Cắt một mảng unsigned char thành một chuỗi 5 byte rồi một double, chạy dưới -fsanitize=undefined.
In alignof của năm kiểu khác nhau trên máy bạn.

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

void * giữ được địa chỉ của mọi đối tượng dữ liệu, nhưng không giải tham chiếu và không làm số học được.
Hoán đổi tổng quát chạy trên unsigned char, kiểu duy nhất chuẩn cho phép nhìn mọi đối tượng như dãy byte.
Xóa kiểu là mất kiểm kiểu, mất kích thước tự động, mất tối ưu, và mất khả năng đọc.
Đẩy void * xuống tầng cài đặt, giữ giao diện công khai có kiểu.
malloc luôn trả về địa chỉ thẳng hàng, nhưng khi bạn tự cắt một vùng lớn thì phải làm tròn lên bằng alignof.