Bài 30.524 phút đọc

_Generic của C11

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

Viết macro chọn hàm theo kiểu đối số bằng _Generic
Nêu bốn giới hạn của _Generic so với nạp chồng thật
Kết hợp _Generic với macro để làm giao diện tổng quát
Biết tgmath.h được xây trên cơ chế này

C11 thêm một cách chọn biểu thức theo kiểu của đối số, ngay lúc biên dịch. Nó là thứ gần nhất với nạp chồng hàm mà C từng có, và nó là nền của tgmath.h. Nó cũng có bốn giới hạn khiến nó không phải nạp chồng thật.

#Cú pháp và cách nó chạy

_Generic(bieu_thuc_dieu_khien,
         kieu1:   ket_qua1,
         kieu2:   ket_qua2,
         default: ket_qua_mac_dinh)

_Generic

Biểu thức chọn một trong các nhánh dựa trên kiểu của biểu thức điều khiển. Việc chọn diễn ra lúc biên dịch, và các nhánh không được chọn thậm chí không cần hợp lệ về mặt ngữ nghĩa.

gen.c

#include <math.h>
#include <stdlib.h>

#define ABS(x) _Generic((x),        \
        int:         abs,           \
        long:        labs,          \
        long long:   llabs,         \
        float:       fabsf,         \
        double:      fabs,          \
        long double: fabsl,         \
        default:     abs)(x)

#define TEN_KIEU(x) _Generic((x),                     \
        int:          "int",                          \
        unsigned:     "unsigned",                     \
        double:       "double",                       \
        float:        "float",                        \
        char:         "char",                         \
        char *:       "char *",                       \
        const char *: "const char *",                 \
        default:      "khong biet")

terminal

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

ABS(-5)      = 5
ABS(-5.5)    = 5.5
ABS(-5.5f)   = 5.5

TEN_KIEU(3)      = int
TEN_KIEU(3.14)   = double
TEN_KIEU(3.14f)  = float
TEN_KIEU('a')    = int
TEN_KIEU(c)      = char
TEN_KIEU("abc")  = char *
TEN_KIEU(m)      = char *
TEN_KIEU(q)      = const char *
TEN_KIEU(i + d)  = double

Nó chọn lúc biên dịch, nên không tốn gì lúc chạy

double x = ABS(-5.5);

/* Sau khi bung macro:
     double x = _Generic((-5.5), int: abs, ..., double: fabs, ...)(-5.5);

   Trinh bien dich thay -5.5 co kieu double, chon nhanh fabs,
   va ca bieu thuc _Generic tro thanh:
     double x = fabs(-5.5);

   Khong co lenh nao lien quan toi viec chon. Do la ly do
   no goi la lua chon TONG QUAT KIEU chu khong phai da hinh. */

Nhánh không được chọn vẫn phải hợp lệ về cú pháp

#define IN(x) _Generic((x),                        \
        int:    printf("%d\n", (x)),                \
        char *: printf("%s\n", (x)))

int a = 5;
IN(a);

/* Ca hai nhanh deu duoc PHAN TICH CU PHAP, nhung chi nhanh int
   duoc TAO MA. Nhanh char* co printf("%s", 5), va gcc canh bao:

     warning: format '%s' expects argument of type 'char *',
              but argument 2 has type 'int' [-Wformat=]

   Vi vay mau tren khong dung duoc. Phai boc moi nhanh thanh HAM: */

static void in_int(int x)          { printf("%d\n", x); }
static void in_chuoi(const char *x) { printf("%s\n", x); }

#define IN(x) _Generic((x),        \
        int:          in_int,      \
        char *:       in_chuoi,    \
        const char *: in_chuoi)(x)

/* Gio moi nhanh chi la mot TEN HAM, va ten ham thi luon hop le. */

#Bốn quy tắc về kiểu

Một: mảng suy biến thành con trỏ

char m[10];

TEN_KIEU(m)      /* -> "char *", KHONG phai "char[10]" */

/* Bieu thuc dieu khien duoc chuyen doi lvalue, tuc la:
     - mang suy bien thanh con tro
     - ham suy bien thanh con tro ham
     - bo qualifier cua kieu mang

   Nen ban KHONG viet duoc nhanh cho "char[10]". */

Hai: hằng ký tự có kiểu int

TEN_KIEU('a')    /* -> "int" */

char c = 'a';
TEN_KIEU(c)      /* -> "char" */

/* Trong C, hang ky tu 'a' co kieu int, khac han C++ noi no la char.
   Bai 3.3 da nhac dieu nay. Neu macro cua ban co nhanh cho char
   ma nguoi dung truyen mot hang ky tu thi ho se roi vao nhanh int. */

Ba: char, signed char, unsigned char là ba kiểu khác nhau

_Generic((x),
    char:          "char",
    signed char:   "signed char",
    unsigned char: "unsigned char")

/* Ba nhanh nay hop le va khong trung nhau, du tren mot he thong
   cu the thi char giong het mot trong hai cai kia ve bieu dien.

   Cung the voi:
     int va long   tren he 32 bit, dau la 4 byte nhung la hai kieu
     long va long long

   Neu ban chi viet nhanh cho int ma nguoi dung truyen long,
   ho roi vao default hoac bi loi bien dich. */

Bốn: const và volatile không bị bỏ

const char *q;

TEN_KIEU(q)      /* -> "const char *", KHONG roi vao nhanh "char *" */

/* Qualifier o TANG NGOAI CUNG cua bieu thuc dieu khien thi bi bo:
     const int a;  TEN_KIEU(a) -> "int"

   Nhung qualifier ben trong kieu con tro thi KHONG:
     const char *p;  -> kieu la "con tro toi const char", giu nguyen

   Nen mot macro nhan chuoi phai co CA HAI nhanh: */

#define DO_DAI(x) _Generic((x),           \
        char *:       strlen,             \
        const char *: strlen)(x)

Hai nhánh cùng kiểu là lỗi biên dịch

_Generic((x),
    int:  a,
    int:  b)          /* error: '_Generic' specifies two compatible types */

/* Nghe hien nhien, nhung no xay ra khi hai typedef tro toi
   cung mot kieu co so: */

typedef int Ma;
typedef int Dem;

_Generic((x),
    Ma:  a,
    Dem: b)           /* error: '_Generic' specifies two compatible types
                         vi Ma va Dem DEU la int */

/* typedef khong tao kieu moi, no chi dat ten khac.
   Bai 29.1 da noi dieu nay voi con tro ham, va o day
   no thanh mot gioi han thuc su. */

Không có nhánh nào khớp và không có default là lỗi

#define F(x) _Generic((x), int: f_int, double: f_double)(x)

char c = 'a';
F(c);          /* error: '_Generic' selector of type 'char' is not
                  compatible with any association */

/* Them default de bien loi thanh mot hanh vi co the doan truoc: */
#define F(x) _Generic((x),          \
        int:     f_int,             \
        double:  f_double,          \
        default: f_mac_dinh)(x)

/* Hoac GIU nguyen loi, neu ban muon nguoi dung phai truyen
   dung kieu. Bo default la mot lua chon co y thuc: no bien
   viec dung sai kieu thanh loi bien dich thay vi loi luc chay. */

#Bốn giới hạn

Giới hạn	Nạp chồng thật làm được	_Generic
Chọn theo SỐ đối số	Có	Không, phải thêm macro đếm đối số
Chọn theo kiểu TRẢ VỀ	Có, trong vài ngôn ngữ	Không, chỉ nhìn đối số
Chuyển đổi ngầm tới kiểu gần nhất	Có	Không, phải khớp kiểu CHÍNH XÁC
Áp dụng cho kiểu do người dùng thêm sau	Có	Không, danh sách nhánh cố định lúc viết macro

Giới hạn quan trọng nhất: phải khớp kiểu chính xác

#define F(x) _Generic((x), double: f_double, default: f_khac)(x)

F(3.14)          /* double  -> f_double */
F(3.14f)         /* float   -> f_khac, KHONG tu chuyen sang double */
F(3)             /* int     -> f_khac */

short s = 5;
F(s);            /* short -> f_khac, du short chuyen sang int duoc */

/* Voi nap chong that thi F(3) se chon ban double neu do la
   ban duy nhat. _Generic thi khong: no so kieu chinh xac,
   khong xet chuyen doi ngam nao.

   He qua thuc te: mot macro _Generic day du cho so nguyen
   phai liet ke: char, signed char, unsigned char, short,
   unsigned short, int, unsigned, long, unsigned long,
   long long, unsigned long long. Muoi mot nhanh. */

Chọn theo số đối số cần thêm một tầng macro

/* Dem so doi so, mo rong pho bien nhung dua vao ##__VA_ARGS__ */
#define DEM_(_1, _2, _3, N, ...) N
#define DEM(...) DEM_(__VA_ARGS__, 3, 2, 1)

#define NOI_(a, b) a##b
#define NOI(a, b)  NOI_(a, b)

#define TAO_1(a)       tao_mot(a)
#define TAO_2(a, b)    tao_hai(a, b)
#define TAO_3(a, b, c) tao_ba(a, b, c)

#define TAO(...) NOI(TAO_, DEM(__VA_ARGS__))(__VA_ARGS__)

TAO(1);          /* -> tao_mot(1)     */
TAO(1, 2);       /* -> tao_hai(1, 2)  */
TAO(1, 2, 3);    /* -> tao_ba(1, 2, 3) */

/* Chay duoc, nhung day la loai ma khien nguoi bao tri
   sau ban khong hieu gi. Dung khi that su can. */

#Ba ứng dụng thật

Một: in giá trị mà không cần nhớ đặc tả

#include <inttypes.h>
#include <stdio.h>

#define DAC_TA(x) _Generic((x),                 \
        char:               "%c",               \
        signed char:        "%hhd",             \
        unsigned char:      "%hhu",             \
        short:              "%hd",              \
        unsigned short:     "%hu",              \
        int:                "%d",               \
        unsigned:           "%u",               \
        long:               "%ld",              \
        unsigned long:      "%lu",              \
        long long:          "%lld",             \
        unsigned long long: "%llu",             \
        float:              "%g",               \
        double:             "%g",               \
        long double:        "%Lg",              \
        char *:             "%s",               \
        const char *:       "%s",               \
        void *:             "%p",               \
        default:            "%p")

#define IN(x)      printf(DAC_TA(x), (x))
#define IN_DONG(x) (printf(#x " = "), IN(x), putchar('\n'))

int    a = 42;
double d = 3.14;
size_t n = 100;

IN_DONG(a);        /* a = 42     */
IN_DONG(d);        /* d = 3.14   */
IN_DONG(n);        /* n = 100    */
IN_DONG(a * 2);    /* a * 2 = 84 */

Nó giải quyết một vấn đề thật

size_t n = 100;

printf("%d\n", n);         /* SAI: size_t khong phai int.
                              Tren he 64 bit, printf doc 4 byte
                              tu mot doi so 8 byte. */

printf("%zu\n", n);        /* dung, nhung phai NHO la %zu */

IN_DONG(n);                 /* macro tu chon, khong phai nho */

/* Voi cac kieu nhu size_t, ptrdiff_t, uint32_t thi dac ta dung
   khac nhau giua cac nen tang, va do la mot nguon loi that.
   Bai 4.3 da liet ke bang dac ta, va no dai. */

Hai: giao diện tổng quát cho container

/* Bai 30.2 sinh ra VecInt_day, VecDouble_day, ...
   Nguoi dung phai nho ten dai. _Generic gom lai mot ten: */

#define vec_day(v, x) _Generic((v),         \
        VecInt *:    VecInt_day,            \
        VecDouble *: VecDouble_day,         \
        VecChar *:   VecChar_day)(v, x)

VecInt    a;
VecDouble b;

vec_day(&a, 42);        /* -> VecInt_day(&a, 42)     */
vec_day(&b, 3.14);      /* -> VecDouble_day(&b, 3.14) */

/* Gioi han: danh sach nhanh phai liet ke MOI kieu vector
   ma du an dung, va no nam trong mot header. Nguoi dung
   thu vien khong them kieu cua ho vao duoc.

   Do la ly do thu vien nhu klib khong dung _Generic ma bat
   nguoi dung goi ten day du. */

Ba: tgmath.h của thư viện chuẩn

#include <tgmath.h>

float       f = 2.0f;
double      d = 2.0;
long double l = 2.0L;

sqrt(f);      /* goi sqrtf */
sqrt(d);      /* goi sqrt  */
sqrt(l);      /* goi sqrtl */

/* Truoc C99 ban phai tu nho ba ten. tgmath.h dinh nghia
   sqrt la mot macro HAM chon mot trong ba: */

#define sqrt(z) __TGMATH_CPLX(z, sqrt, csqrt)

/* Vi no la macro HAM, no chi bung khi co dau ngoac ngay sau ten.
   Nen dong nay VAN chay: */

double (*p)(double) = sqrt;    /* sqrt khong theo sau boi (
                                  -> macro khong bung
                                  -> day la ham sqrt that */

printf("%f\n", p(2.0));       /* 1.414214 */

Ba chỗ macro _Generic khác hàm thật

Macro của bạn không lấy địa chỉ được. Nếu bạn viết một macro _Generic giống hàm thì nó không truyền được làm callback. Riêng tgmath.h may mắn hơn: vì nó dùng macro hàm, tên không theo sau dấu ngoặc vẫn là hàm thật.
Đối số bị đánh giá nhiều lần nếu bạn viết ẩu. Trong _Generic((x), int: f)(x) thì x xuất hiện hai lần. Biểu thức điều khiển không được đánh giá, chỉ lấy kiểu, nên thực tế chỉ một lần. Nhưng nếu bạn viết _Generic((x), int: f(x)) thì lại khác.
Thông báo lỗi trỏ vào macro. Cùng vấn đề với mọi macro, xem Bài 19.4.

/* Bieu thuc dieu khien KHONG duoc danh gia: */

int i = 0;

TEN_KIEU(i++);          /* i van bang 0 sau dong nay */

/* Chuan noi ro: "The controlling expression of a generic selection
   is not evaluated."  Chi kieu cua no duoc dung.

   Nhung doi so cua LOI GOI thi co danh gia: */

#define F(x) _Generic((x), int: f_int)(x)
/*                     ^^^ khong danh gia    ^^^ CO danh gia */

F(i++);                  /* i tang mot lan, do la lan o cuoi */

Tự làm thử

Viết macro TEN_KIEU và thử với hằng ký tự, biến char, chuỗi hằng, mảng char, và const char *.
Viết ABS bằng _Generic và kiểm với int, float, double.
Viết hai nhánh cùng kiểu qua hai typedef và đọc thông báo lỗi.
Viết macro IN_DONG và dùng nó với size_t, xác nhận nó in đúng mà không cần bạn nhớ %zu.
Chạy TEN_KIEU(i++) rồi in i, xác nhận nó không đổi.
Thử lấy địa chỉ của sqrt sau khi include tgmath.h và sau khi include math.h, so hai kết quả.

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

_Generic chọn một nhánh theo kiểu của biểu thức điều khiển, ngay lúc biên dịch, và không tốn gì lúc chạy.
Mảng suy biến thành con trỏ, hằng ký tự có kiểu int, và const char * không rơi vào nhánh char *.
Nó khớp kiểu chính xác, không xét chuyển đổi ngầm, nên một macro đầy đủ cho số nguyên cần mười một nhánh.
Mọi nhánh phải hợp lệ về cú pháp, nên hãy để mỗi nhánh chỉ là một tên hàm.
Biểu thức điều khiển không được đánh giá, chỉ kiểu của nó được dùng.