1
2
3
4
5

// 普通宏只能接受固定参数
#define PRINT_INT(x) printf("Value: %d\n", x)

// 但你想支持 PRINT_INT(1), PRINT_INT(1, 2, 3) 各种花式调用？
// 可变参数宏就是来解决这个问题的！

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

#include <stdio.h>

// 可变参数宏：args 是传递给 printf 的可变部分
#define DEBUG_PRINT(fmt, ...) printf(fmt, __VA_ARGS__)

int main(void) {
    int x = 42;
    double y = 3.14;

    DEBUG_PRINT("x = %d\n", x);          // x = 42
    DEBUG_PRINT("x = %d, y = %.2f\n", x, y);  // x = 42, y = 3.14

    return 0;
}

1
2
3
4
5
6
7

#include <stdio.h>

#define DEBUG_PRINT(fmt, ...) printf(fmt, __VA_ARGS__)

// 如果你只传一个参数：
DEBUG_PRINT("Hello");  // 展开后变成：printf("Hello", );  ← 多了一个逗号！
// 编译错误！谁见了都想打人！

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

#include <stdio.h>

// ① C23 标准写法：__VA_OPT__(,) 表示"可变参数非空时，在这里插一个逗号"
#define DEBUG_PRINT(fmt, ...) printf(fmt __VA_OPT__(,) __VA_ARGS__)

// ② GNU 扩展写法：## 前缀让预处理器在可变参数为空时吞掉前面的逗号
//    （GCC / Clang 支持；-pedantic 下会提示这是 GNU 扩展）
#define DEBUG_PRINT_GNU(fmt, ...) printf(fmt, ##__VA_ARGS__)

int main(void) {
    DEBUG_PRINT("Hello\n");             // ✅ 展开为 printf("Hello\n");
    DEBUG_PRINT("x = %d\n", 42);        // ✅ 展开为 printf("x = %d\n", 42);

    DEBUG_PRINT_GNU("Hello\n");         // ✅ 同上（GCC / Clang）
    DEBUG_PRINT_GNU("x = %d\n", 42);    // ✅ 同上（GCC / Clang）

    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

#include <stdio.h>
#include <stdarg.h>

// 日志级别：0=静默, 1=ERROR, 2=WARN, 3=INFO, 4=DEBUG
#define LOG_LEVEL 3

// 真正干活的函数：先打印级别/文件/行号，再把可变参数交给 vprintf
void log_msg(const char *level, const char *file, int line, const char *fmt, ...) {
    va_list args;
    printf("[%s] %s:%d: ", level, file, line);
    va_start(args, fmt);
    vprintf(fmt, args);  // vprintf 接收 va_list
    va_end(args);
    printf("\n");
}

// 关键技巧：用预处理指令决定"某个级别的日志到底编不编进程序"。
// 级别不够时宏展开成空语句，既没有运行时开销，也不会产生"参数未使用"警告。
#if LOG_LEVEL >= 1
#  define LOG_ERROR(...) log_msg("ERROR", __FILE__, __LINE__, __VA_ARGS__)
#else
#  define LOG_ERROR(...) ((void)0)
#endif
#if LOG_LEVEL >= 2
#  define LOG_WARN(...)  log_msg("WARN",  __FILE__, __LINE__, __VA_ARGS__)
#else
#  define LOG_WARN(...)  ((void)0)
#endif
#if LOG_LEVEL >= 3
#  define LOG_INFO(...)  log_msg("INFO",  __FILE__, __LINE__, __VA_ARGS__)
#else
#  define LOG_INFO(...)  ((void)0)
#endif
#if LOG_LEVEL >= 4
#  define LOG_DEBUG(...) log_msg("DEBUG", __FILE__, __LINE__, __VA_ARGS__)
#else
#  define LOG_DEBUG(...) ((void)0)
#endif

int main(void) {
    LOG_ERROR("这是一个错误: code=%d", 500);   // [ERROR] main.c:47: 这是一个错误: code=500
    LOG_WARN("内存使用率: %.1f%%", 85.5);      // [WARN] main.c:48: 内存使用率: 85.5%
    LOG_INFO("服务启动成功");                  // [INFO] main.c:49: 服务启动成功
    LOG_DEBUG("调试信息: x=%d, y=%d", 1, 2);   // 级别不够，这行被编译掉了

    return 0;
}

1
2
3
4
5
6

// 传统的痛苦写法
int arr[3] = {1, 2, 3};
int sum = 0;
for (int i = 0; i < 3; i++) {
    sum += arr[i];
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

#include <stdio.h>

int main(void) {
    // 传统写法：先定义变量，再使用
    int arr[3] = {1, 2, 3};

    // C99 复合字面量：直接在表达式中创建数组
    // (type){ initializers }
    int sum = 0;
    for (int i = 0; i < 3; i++) {
        sum += ((int[]){1, 2, 3})[i];  // 匿名数组，即用即弃
    }
    printf("sum = %d\n", sum);  // sum = 6

    // 更骚的操作：直接传给函数
    int max = 0;
    // 复合字面量是"匿名对象"，只能通过指针去访问它的地址
    int *numbers = (int[]){5, 2, 8, 1, 9};
    for (int i = 0; i < 5; i++) {
        if (numbers[i] > max) max = numbers[i];
    }
    printf("max = %d\n", max);  // max = 9

    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

#include <stdio.h>

struct Point {
    int x;
    int y;
};

struct Rectangle {
    struct Point top_left;
    struct Point bottom_right;
};

int main(void) {
    // 传统写法：先定义，再赋值
    struct Point p1;
    p1.x = 0;
    p1.y = 1;

    // C99 复合字面量：一条语句搞定！
    struct Point p2 = (struct Point){10, 20};  // x=10, y=20
    printf("p2: x=%d, y=%d\n", p2.x, p2.y);     // p2: x=10, y=20

    // 嵌套复合字面量
    struct Rectangle rect = (struct Rectangle){
        (struct Point){0, 100},    // top_left
        (struct Point){50, 0}      // bottom_right
    };
    printf("Rect: top_left=(%d,%d), bottom_right=(%d,%d)\n",
           rect.top_left.x, rect.top_left.y,
           rect.bottom_right.x, rect.bottom_right.y);
    // Rect: top_left=(0,100), bottom_right=(50,0)

    // 指针也可以用复合字面量！
    struct Point *ptr = &(struct Point){30, 40};  // 匿名结构体的地址
    printf("ptr: x=%d, y=%d\n", ptr->x, ptr->y);   // ptr: x=30, y=40

    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

#include <stdio.h>

struct Config {
    int port;
    char *host;
    int debug_level;
};

int main(void) {
    // 使用指定初始化器，只初始化需要的字段
    struct Config *cfg = &(struct Config){
        .host = "localhost",
        .port = 8080,
        .debug_level = 2
    };

    printf("连接 %s:%d (debug=%d)\n",
           cfg->host, cfg->port, cfg->debug_level);
    // 连接 localhost:8080 (debug=2)

    return 0;
}

1
2
3
4
5
6
7

// 数组复合字面量
(int[]){1, 2, 3}
(int[3]){1, 2, 3}

// 结构体复合字面量
(struct Point){10, 20}
 &(struct Point){10, 20}  // 取地址

1
2
3
4
5

({  // 左圆括号 + 左花括号
    int x = 1;
    int y = 2;
    x + y;  // 这个表达式的值是最后一个语句的值
})  // 右花括号 + 右圆括号

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

#include <stdio.h>

int main(void) {
    // 语句表达式的值 = 最后一个表达式的值
    int result = ({
        int a = 10;
        int b = 20;
        a + b;  // 30 — 这个值被外层接收
    });
    printf("result = %d\n", result);  // result = 30

    // 甚至可以写循环！
    int sum = ({
        int total = 0;
        for (int i = 1; i <= 5; i++) {
            total += i;
        }
        total;  // 循环结束后，total = 15
    });
    printf("sum 1..5 = %d\n", sum);  // sum 1..5 = 15

    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

// 伪代码（函数式风格）
// let x = 10 in x * 2

// 在 C 里用语句表达式模拟：
#include <stdio.h>

int main(void) {
    // 模拟 let x = 10 in x * 2
    int result = ({
        int x = 10;
        x * 2;
    });
    printf("%d\n", result);  // 20

    // 模拟 let x = 5, y = 3 in (x + y) * (x - y)
    int poly = ({
        int x = 5;
        int y = 3;
        (x + y) * (x - y);
    });
    printf("%d\n", poly);  // (5+3)*(5-3) = 8*2 = 16

    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

#include <stdio.h>

// 危险！如果传入 x++ 会被求值两次
#define SQUARE_BAD(x) ((x) * (x))

// 安全版本：语句表达式确保求值一次
#define SQUARE_SAFE(x) ({ \
    typeof(x) _x = (x);   \
    _x * _x;              \
})

int main(void) {
    int num = 3;
    printf("SQUARE_BAD(%d) = %d\n", num, SQUARE_BAD(num));   // 9 ✅

    num = 3;
    int bad = SQUARE_BAD(num++);   // 展开成 ((num++) * (num++))
    // ⚠️ 未定义行为：同一个对象在两次未定序的修改之间被改了两次。
    // 结果是 9、12 还是别的什么，取决于编译器与优化级别。
    printf("SQUARE_BAD(num++) = %d, num = %d\n", bad, num);

    num = 3;
    printf("SQUARE_SAFE(%d) = %d\n", num, SQUARE_SAFE(num));  // 9 ✅

    num = 3;
    int good = SQUARE_SAFE(num++);  // 先把 num++ 的结果存进 _x，再算 _x * _x
    printf("SQUARE_SAFE(num++) = %d, num = %d\n", good, num); // 9, 4 ✅

    return 0;
}

1
2
3
4
5

// ❌ 不能这样用：语句表达式是 GNU 扩展，非 GNU 编译器会报错的
// #include <stdio.h>
// int main(void) { ... }  // 需要加 -std=gnu99 或 -std=gnu11

// ✅ 使用时应该加上 -std=gnu99 以上标准

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

#include <stdio.h>

int main(void) {
    int x = 10;
    double y = 3.14;

    // 获取 x 的类型，然后用它声明新变量
    typeof(x) a = 20;      // int a = 20;
    typeof(y) b = 2.71;    // double b = 2.71;

    printf("a = %d, b = %.2f\n", a, b);  // a = 20, b = 2.71

    // 获取表达式的类型
    typeof(x + y) result = x + y;  // double result = 10 + 3.14 = 13.14
    printf("result = %.2f\n", result);  // result = 13.14

    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

#include <stdio.h>

// 安全的 max 宏：自动推断类型
#define MAX(a, b) ({ \
    typeof(a) _a = (a); \
    typeof(b) _b = (b); \
    _a > _b ? _a : _b; \
})

// 安全的 swap 宏
#define SWAP(x, y) do { \
    typeof(x) _temp = (x); \
    (x) = (y); \
    (y) = _temp; \
} while(0)

int main(void) {
    int i1 = 5, i2 = 10;
    printf("MAX(%d, %d) = %d\n", i1, i2, MAX(i1, i2));  // 10

    double d1 = 3.14, d2 = 2.71;
    printf("MAX(%.2f, %.2f) = %.2f\n", d1, d2, MAX(d1, d2));  // 3.14

    SWAP(i1, i2);
    printf("After swap: i1=%d, i2=%d\n", i1, i2);  // i1=10, i2=5

    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

#include <stdio.h>

int main(void) {
    const int ci = 100;
    volatile int vi = 200;

    // typeof(ci) 是 const int，不适合做变量类型
    typeof(ci) x = 10;     // const int x = 10;
    // x = 20;  // ❌ 错误！x 是 const

    // typeof_unqual 去掉限定符
    typeof_unqual(ci) y = 10;  // int y = 10;
    y = 30;  // ✅ OK！
    printf("y = %d\n", y);  // y = 30

    typeof_unqual(vi) z = 200;  // int z = 200;
    printf("z = %d\n", z);  // z = 200

    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

#include <stdio.h>

int main(void) {
    // 5 的二进制是 101，有 2 个 1
    printf("popcount(5)   = %d\n", __builtin_popcount(5));      // 2
    // 7 的二进制是 111，有 3 个 1
    printf("popcount(7)   = %d\n", __builtin_popcount(7));      // 3
    // 255 的二进制是 11111111，有 8 个 1
    printf("popcount(255) = %d\n", __builtin_popcount(255));    // 8

    // __builtin_popcountll 用于 64 位
    printf("popcountll(0xFFFFFFFFFFFFFFFF) = %d\n",
           __builtin_popcountll(0xFFFFFFFFFFFFFFFFULL));  // 64

    // 应用场景：判断一个数是否是 2 的幂
    int n = 16;
    if (__builtin_popcount(n) == 1) {
        printf("%d 是 2 的幂！\n", n);  // 16 是 2 的幂！
    } else {
        printf("%d 不是 2 的幂\n", n);
    }

    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

#include <stdio.h>

// Linux 内核风格的 likely/unlikely 宏
#define likely(x)   __builtin_expect(!!(x), 1)   // 很可能为真
#define unlikely(x) __builtin_expect(!!(x), 0)   // 很可能为假

int main(void) {
    int error = 0;

    // 告诉编译器：这个条件很不可能发生
    if (unlikely(error)) {
        printf("出错了！\n");
    } else {
        printf("一切正常\n");  // 编译器会把这个分支优化为"主要执行路径"
    }

    // 另一个例子
    int value = 100;
    if (likely(value > 0)) {
        printf("value 是正数: %d\n", value);  // 编译器优先优化这个分支
    }

    return 0;
}

1
2
3
4

// 摘自 Linux 内核（简化）
if (unlikely(ptr == NULL)) {
    return -ENOMEM;  // 很少发生的错误情况
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

#include <stdio.h>
#include <stddef.h>  // 标准 offsetof

struct Point {
    int x;       // 偏移 0
    int y;       // 偏移 4
    double z;    // 偏移 8（double 需要 8 字节对齐）
};

// 位域结构体：成员共用同一个存储单元，"偏移量"没有意义
struct Packet {
    unsigned int header  : 4;   // 前 4 位：头部
    unsigned int type    : 4;   // 中 4 位：类型
    unsigned int payload : 24;  // 后 24 位：数据
};

int main(void) {
    // offsetof 和 __builtin_offsetof 的结果完全一致
    printf("offsetof(Point, x) = %zu\n", offsetof(struct Point, x));             // 0
    printf("offsetof(Point, y) = %zu\n", offsetof(struct Point, y));             // 4
    printf("offsetof(Point, z) = %zu\n", offsetof(struct Point, z));             // 8
    printf("__builtin_offsetof(Point, z) = %zu\n",
           __builtin_offsetof(struct Point, z));                                 // 8

    printf("sizeof(struct Packet) = %zu\n", sizeof(struct Packet));              // 4

    // ❌ 下面这行会编译失败：Cannot compute offset of bit-field 'header'
    // printf("%zu\n", offsetof(struct Packet, header));

    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

#include <stdio.h>

// 简单的断言宏
#define ASSERT(cond) do { \
    if (!(cond)) { \
        fprintf(stderr, "Assertion failed: %s\n", #cond); \
        __builtin_trap();  /* 触发 SIGTRAP，让调试器停下来 */ \
    } \
} while(0)

int divide(int a, int b) {
    ASSERT(b != 0);  // 运行时检查：除数不能为 0
    return a / b;
}

int main(void) {
    printf("正常情况: 10/2 = %d\n", divide(10, 2));  // 5

    // 在调试器中运行时会停在这里！
    // divide(10, 0);

    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

#include <stdio.h>
#include <time.h>
#include <stdlib.h>   // malloc / free / clock

#define N 10000000

// 不使用 prefetch 的版本
long long sum_without_prefetch(int *arr, int n) {
    long long sum = 0;
    for (int i = 0; i < n; i++) {
        sum += arr[i];
    }
    return sum;
}

// 使用 prefetch 的版本
long long sum_with_prefetch(int *arr, int n) {
    long long sum = 0;
    for (int i = 0; i < n; i++) {
        // 预取 arr[i+16]，即提前加载未来的数据
        // 0 = 预读到所有缓存层级
        // 1 = 预读指令缓存（这里不合适，仅做示例）
        // arr+16 是在访问 arr[i] 时，提前告诉 CPU "一会儿要用 arr[i+16]"
        if (i + 16 < n) {
            __builtin_prefetch(&arr[i + 16], 0, 3);  // 3 = 临时性读
        }
        sum += arr[i];
    }
    return sum;
}

int main(void) {
    int *arr = malloc(N * sizeof(int));
    for (int i = 0; i < N; i++) arr[i] = i + 1;

    clock_t start = clock();
    long long s1 = sum_without_prefetch(arr, N);
    clock_t t1 = clock() - start;

    start = clock();
    long long s2 = sum_with_prefetch(arr, N);
    clock_t t2 = clock() - start;

    printf("Without prefetch: sum=%lld, time=%.3fms\n", s1, t1 * 1000.0 / CLOCKS_PER_SEC);
    printf("With prefetch:    sum=%lld, time=%.3fms\n", s2, t2 * 1000.0 / CLOCKS_PER_SEC);

    free(arr);
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

#include <stdio.h>

int main(void) {
    // _Generic 的语法：
    // _Generic(expr, type1: value1, type2: value2, ..., default: valueN)
    //
    // 它会检查 expr 的类型，然后返回对应类型的值

    int i = 42;
    double d = 3.14;
    char *s = "hello";

    // 根据 i 的类型（int）选择输出
    printf("%s\n", _Generic(i, int: "i 是 int 类型",
                                 double: "i 是 double 类型",
                                 default: "i 是其他类型"));  // i 是 int 类型

    printf("%s\n", _Generic(d, int: "d 是 int 类型",
                                 double: "d 是 double 类型",
                                 default: "d 是其他类型"));  // d 是 double 类型

    printf("%s\n", _Generic(s, int: "s 是 int 类型",
                                 double: "s 是 double 类型",
                                 char *: "s 是 char* 类型",
                                 default: "s 是其他类型"));  // s 是 char* 类型

    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

#include <stdio.h>

// 泛型打印：让 _Generic 只负责"挑格式串"，真正的打印还是交给 printf。
// 这一点很重要 —— _Generic 的每个分支都必须是一个类型正确的表达式，
// 直接把 printf(...) 塞进分支里会因为"类型对不上"而编译失败。
#define PRINT_VALUE(x) printf(_Generic((x), \
    int:    "int: %d\n", \
    double: "double: %.2f\n", \
    char:   "char: '%c'\n", \
    char *: "char*: \"%s\"\n", \
    default: "未知类型\n"), (x))

// 泛型加法：根据左操作数的类型选择计算分支
#define ADD(a, b) _Generic((a), \
    int:   ((a) + (b)), \
    double: ((a) + (b)), \
    default: 0 \
)

int main(void) {
    char c = 'A';

    PRINT_VALUE(42);       // int: 42
    PRINT_VALUE(3.14);     // double: 3.14
    PRINT_VALUE(c);        // char: 'A'
    PRINT_VALUE("hello");  // char*: "hello"

    printf("ADD(1, 2) = %d\n", ADD(1, 2));            // 3
    printf("ADD(1.5, 2.5) = %.1f\n", ADD(1.5, 2.5));  // 4.0

    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

#include <stdio.h>

// typeof 曾是 GCC/Clang 扩展，C23 已把它标准化（另有 typeof_unqual 变体）
// 这里的 MIN/MAX 不用 _Generic，而是靠 typeof 声明"同类型的临时变量"，
// 从而保证每个参数只求值一次（避免 MIN(i++, j++) 这种副作用被放大）
#define MIN(a, b) ({ \
    __typeof__(a) _a = (a); \
    __typeof__(b) _b = (b); \
    (void)(&_a != &(_b)); /* 类型不同时产生警告 */ \
    _a < _b ? _a : _b; \
})

#define MAX(a, b) ({ \
    __typeof__(a) _a = (a); \
    __typeof__(b) _b = (b); \
    (void)(&_a != &(_b)); \
    _a > _b ? _a : _b; \
})

int main(void) {
    int i1 = 5, i2 = 10;
    printf("MIN(%d, %d) = %d\n", i1, i2, MIN(i1, i2));    // 5
    printf("MAX(%d, %d) = %d\n", i1, i2, MAX(i1, i2));    // 10

    double d1 = 3.14, d2 = 2.71;
    printf("MIN(%.2f, %.2f) = %.2f\n", d1, d2, MIN(d1, d2));  // 2.71
    printf("MAX(%.2f, %.2f) = %.2f\n", d1, d2, MAX(d1, d2));  // 3.14

    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

#include <stdio.h>
#include <limits.h>

// constexpr 对象：值必须在编译期确定，且本身就是 const
constexpr int SQUARE_SIDE = 4;
constexpr int AREA = SQUARE_SIDE * SQUARE_SIDE;   // 16，可用在常量表达式里
constexpr double PI = 3.14159265358979323846;

// 编译期断言：对常量表达式做静态检查
static_assert(AREA == 16, "AREA 应该是 16");

// ❌ 这是 C++ 的写法，在 C 里直接编译报错：
// constexpr int square(int x) { return x * x; }

int main(void) {
    int grid[AREA];                     // AREA 是编译期常量，这是"定长数组"而非 VLA
    printf("grid 有 %zu 个元素\n", sizeof(grid) / sizeof(grid[0]));  // 16
    printf("SQUARE_SIDE = %d, PI = %.5f\n", SQUARE_SIDE, PI);
    printf("BITINT_MAXWIDTH = %llu\n", (unsigned long long)BITINT_MAXWIDTH);

    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

#include <stdio.h>

// ① 宏：最老牌的"编译期求值"
#define SQUARE(x) ((x) * (x))

// ② constexpr 对象：结果可以在常量表达式里使用
constexpr int SIDE = 3;
constexpr int AREA = SQUARE(SIDE);       // 9

// ③ 编译期断言，把错误提前到编译阶段
static_assert(SQUARE(5) == 25, "宏展开的常量检查");

int main(void) {
    int board[SIDE * SIDE];              // 定长数组：9 个 int
    printf("SIDE=%d, AREA=%d, 棋盘格数=%zu\n",
           SIDE, AREA, sizeof(board) / sizeof(board[0]));

    return 0;
}

1
2
3
4
5

// 某实现可能这样定义
#define NULL 0
// 也可能这样定义
#define NULL ((void*)0)
// C23 起，还可以定义成 nullptr（见下）

1
2
3
4
5
6

void foo(char *p);
foo(NULL);   // 没问题，两种定义都能隐式转换成指针

// 但如果想在宏里区分"整数 0"和"空指针"，就没辙了：
//   _Generic(NULL, int: ..., void *: ...)   ← 到底选哪个分支，取决于实现
// 在 C++ 里重载函数时也是同理（C 没有重载，但 _Generic 会遇到同样的问题）。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

#include <stdio.h>
#include <stddef.h>   // nullptr_t 定义在这里

void foo(char *p) {
    if (p == NULL) {
        printf("p 是空指针！\n");
    } else {
        printf("p 指向: %s\n", p);
    }
}

int main(void) {
    char *p1 = nullptr;  // 类型是 nullptr_t
    char *p2 = NULL;

    printf("p1 == p2: %s\n", p1 == p2 ? "相等" : "不相等");  // 相等

    foo(nullptr);  // p 是空指针！
    foo("hello"); // p 指向: hello

    // nullptr_t 类型
    _Static_assert(sizeof(nullptr_t) == sizeof(void*),
                   "nullptr_t 应该和指针大小一样");

    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

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

// C23 标准化。之前的标准写法是 _Noreturn（C11 引入的函数说明符，
// 至今仍然可用，但 C23 起更推荐 [[noreturn]]）
[[noreturn]] void fatal_error(const char *msg) {
    printf("严重错误: %s\n", msg);
    exit(1);  // 永远不会返回
}

// 注意：不要试图自己写一个叫 __builtin_trap 的函数去"覆盖"编译器内置函数，
// 那样会报 "definition of builtin function"。编译器内置的 __builtin_trap()
// 本身就等价于一条 trap 指令，见 27.5.4。

int main(void) {
    printf("程序开始\n");
    fatal_error("测试错误");  // 永远不会执行到这里
    printf("永远不会打印\n");  // 编译器可能会警告
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

#include <stdio.h>
#include <stdlib.h>
#include <string.h>   // strlen / strcpy

// 基本形式
[[nodiscard]] int * allocate_array(int size) {
    int *arr = malloc(size * sizeof(int));
    return arr;
}

// 带 message 的形式（C23）
[[nodiscard("请检查内存是否释放")]] char *strdup_safe(const char *s) {
    char *copy = malloc(strlen(s) + 1);
    if (copy) strcpy(copy, s);
    return copy;
}

int main(void) {
    // ✅ 正确用法：接收返回值
    int *arr = allocate_array(10);
    printf("arr 指针本身占 %zu 字节（注意：不是数组大小）\n", sizeof(arr));
    printf("分配了 %d 个 int，共 %zu 字节\n", 10, 10 * sizeof(int));

    // ❌ 错误用法：忽略返回值，编译器会报警告！
    allocate_array(100);  // 警告：忽略 nodiscard 函数的返回值！

    // 带 message 的形式：警告里会带上"请检查内存是否释放"
    // strdup_safe("hello");  // （取消注释即可看到警告）

    free(arr);
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

#include <stdio.h>

// 在调试时有用，但发布时可能没用到
[[maybe_unused]] int debug_counter = 0;

// 函数参数可能没用到
int process_data(int used_param, [[maybe_unused]] int unused_param) {
    [[maybe_unused]] int temp = 42;  // 临时变量，用 or 不用都行
    return used_param * 2;
}

int main(void) {
    debug_counter++;  // 可能用，可能不用
    printf("result = %d\n", process_data(10, 999));  // result = 20
    // 编译器不会抱怨 debug_counter 和 unused_param 没被使用

    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

#include <stdio.h>

// 废弃旧 API，建议使用新 API
[[deprecated("请使用 new_calculate 代替")]]
int old_calculate(int x) {
    return x * 2;
}

// 不带 message 的基本形式
[[deprecated]]
char *old_function(void) {
    return "旧函数";
}

int new_calculate(int x) {
    return x * x;
}

int main(void) {
    int r1 = new_calculate(5);   // ✅ 正常
    int r2 = old_calculate(5);   // ⚠️ 警告：使用了废弃的 old_calculate
    printf("r1=%d, r2=%d\n", r1, r2);

    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

#include <stdio.h>

const char *get_day_type(int day) {
    switch (day) {
        case 1:
        case 2:
        case 3:
        case 4:
        case 5:
            return "工作日";
        case 6:
            return "周六";
        case 7:
            return "周日";
        default:
            return "无效日期";
    }
}

// 使用 fallthrough 标记"有意为之"的穿透
const char *get_day_name(int day) {
    switch (day) {
        case 1:
            return "星期一";
        case 2:
            return "星期二";
        case 3:
            return "星期三";
        case 4:
            return "星期四";
        case 5:
            return "星期五";
        case 6:
            [[fallthrough]];  // 故意穿透：周六和周日共用一套逻辑
        case 7:
            return "周末";
        default:
            return "无效";
    }
}

int main(void) {
    printf("%s\n", get_day_type(3));   // 工作日
    printf("%s\n", get_day_name(6));   // 周末（穿透到 case 7）
    printf("%s\n", get_day_name(7));   // 周末

    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

#include <stdio.h>

int divide(int a, int b) {
    // __builtin_expect(b == 0, 0) 表示"这个条件基本不会成立"
    if (__builtin_expect(b == 0, 0)) {
        printf("除数不能为 0！\n");
        return 0;
    }
    return a / b;
}

int main(void) {
    printf("10 / 2 = %d\n", divide(10, 2));   // 5
    printf("10 / 3 = %d\n", divide(10, 3));   // 3
    divide(10, 0);                            // 除数不能为 0！

    return 0;
}

1

warning: unknown attribute 'no_unique_address' ignored [-Wunknown-attributes]

1

struct tag { unsigned char dummy; };

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

/* point.h —— 一个规范的头文件 */
#ifndef POINT_H
#define POINT_H

struct Point {
    int x;
    int y;
};

int point_distance_squared(const struct Point *a, const struct Point *b);

#endif /* POINT_H */

1
2
3
4
5
6
7
8

/* point.c —— 实现放在源文件里 */
#include "point.h"

int point_distance_squared(const struct Point *a, const struct Point *b) {
    int dx = a->x - b->x;
    int dy = a->y - b->y;
    return dx * dx + dy * dy;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

#include <stdio.h>

int add(int a, int b) {
    int result;
    // __asm__ 是 GCC 的内联汇编关键字
    __asm__ volatile (
        "addl %%ebx, %%eax"  // 汇编指令：eax = eax + ebx
        : "=a"(result)       // 输出操作数：result 放在 eax
        : "a"(a), "b"(b)     // 输入操作数：a 放在 eax，b 放在 ebx
    );
    return result;
}

int main(void) {
    printf("add(3, 4) = %d\n", add(3, 4));  // 7
    return 0;
}

1
2
3
4
5
6

__asm__ volatile (
    "汇编指令"
    : 输出操作数 (约束)  // "=r" = 输出到寄存器，"=a" = eax, "=b" = ebx
    : 输入操作数 (约束)  // "r" = 任意寄存器，"i" = 立即数
    : 被修改的寄存器     // 告诉编译器哪些寄存器会被用到（clobber）
);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

#include <stdio.h>

// 读取 CPU 时间戳计数器（x86 / x86-64 专属）
// rdtsc 把 64 位计数拆成 edx:eax 两半，所以要分别接收再拼起来。
// 注意：在 64 位下不能用 "=A" 约束 —— 那只是 32 位 x86 的写法。
static inline unsigned long long get_cycles(void) {
    unsigned int lo, hi;
    __asm__ volatile (
        "rdtsc"
        : "=a"(lo), "=d"(hi)     // eax → lo，edx → hi
    );
    return ((unsigned long long)hi << 32) | lo;
}

int main(void) {
    unsigned long long start = get_cycles();

    // 干点啥
    long long sum = 0;
    for (int i = 0; i < 1000000; i++) sum += i;

    unsigned long long end = get_cycles();
    printf("执行消耗了 %llu 个时钟周期\n", end - start);
    printf("sum = %lld\n", sum);

    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

#include <stdio.h>

// C23 #embed：把二进制文件内容原样嵌入
// 这会生成一个 unsigned char 数组，大小正好等于文件字节数
const unsigned char favicon_data[] = {
    #embed "favicon.bin"
};

// limit(N)：最多嵌入 N 字节（相当于"截断"）
const unsigned char logo_head[] = {
    #embed "favicon.bin" limit(16)
};

// prefix / suffix：在"整段展开结果"的首/尾各追加一段内容（各只生效一次）
// 标准里的经典用法：suffix(,) 后紧跟一个 0，就给数组补上了结束符
const unsigned char logo_z[] = {
    #embed "favicon.bin" limit(4) suffix(,)
    0
};

int main(void) {
    printf("favicon 大小: %zu 字节\n", sizeof(favicon_data));
    printf("只取前 16 字节: %zu 字节\n", sizeof(logo_head));
    printf("前 4 字节 + 结束符: %zu 字节\n", sizeof(logo_z));

    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

#include <stdio.h>

// 情形一：文件存在且非空 —— 正常嵌入前 4 个字节，再加一个 0 结尾
const unsigned char data1[] = {
    #embed "favicon.bin" limit(4) suffix(,)
    0
};

// 情形二：用 limit(0) 强制"资源被视为空"，
// 于是整个 #embed 被 if_empty 里的内容替换，数组只剩一个 0
const unsigned char data2[] = {
    #embed "favicon.bin" limit(0) if_empty(0)
};

static_assert(sizeof(data2) == 1, "limit(0) 会把资源视为空，从而走 if_empty 分支");

int main(void) {
    printf("data1 大小: %zu 字节\n", sizeof(data1));  // 5
    printf("data2 大小: %zu 字节\n", sizeof(data2));  // 1
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

#include <stdio.h>
#include <limits.h>

int main(void) {
    // _BitInt(N)：正好 N 位的整数（含符号位）
    _BitInt(7) small = 63;                    // 7 位有符号：-64 ~ 63
    unsigned _BitInt(7) usmall = 127;         // 7 位无符号：0 ~ 127

    // 用 wb 后缀让字面量自己挑一个放得下的位宽
    _BitInt(128) big = 12345678901234567890wb;

    printf("small=%d, usmall=%u\n", (int)small, (unsigned)usmall);
    printf("sizeof(_BitInt(7))   = %zu 字节\n", sizeof(_BitInt(7)));
    printf("sizeof(_BitInt(128)) = %zu 字节\n", sizeof(big));
    printf("BITINT_MAXWIDTH      = %llu\n", (unsigned long long)BITINT_MAXWIDTH);

    // 只要结果不超过 128 位，就能安全地做大数运算
    _BitInt(128) a = (_BitInt(128))1 << 100;   // 2^100
    _BitInt(128) b = (_BitInt(128))1 << 20;    // 2^20
    _BitInt(128) c = a * b;                    // 2^120，仍在 128 位之内
    _BitInt(128) expected = (_BitInt(128))1 << 120;
    printf("2^100 * 2^20 == 2^120 ? %s\n", (c == expected) ? "是" : "否");

    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

#include <stdio.h>

int main(void) {
    // 基本声明：和普通整数一样可以赋初值、参与运算
    _BitInt(8)   byte_val  = -1;      // 8 位有符号：-128 ~ 127
    _BitInt(16)  word_val  = 1000;    // 16 位有符号
    _BitInt(32)  dword_val = 100000;  // 32 位有符号
    unsigned _BitInt(8) ubyte = 255;  // 8 位无符号：0 ~ 255

    printf("%d %d %d %u\n",
           (int)byte_val, (int)word_val, (int)dword_val, (unsigned)ubyte);

    // F(100) ≈ 3.54e20，需要约 69 位，96 位无符号绰绰有余
    unsigned _BitInt(96) fib1 = 1, fib2 = 1, fibn = 0;
    for (int i = 3; i <= 100; i++) {
        fibn = fib1 + fib2;
        fib1 = fib2;
        fib2 = fibn;
    }
    printf("F(100) > 2^64 ? %s\n",
           (fibn > ((unsigned _BitInt(96))1 << 64)) ? "是" : "否");

    // printf 家族没有任何转换说明符能直接打印 _BitInt。
    // 值能放进标准类型时可以转换后打印（超宽会按 2^N 取模截断）；
    // 想完整打印大数，只能自己按位/按十进制逐位提取（见 27.13.4）。
    printf("F(100) 的低 64 位 = %llu\n", (unsigned long long)fibn);

    return 0;
}