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

#include <stdio.h>

int main() {
    int a = 42;
    int *ptr = &a;  // & 是取地址运算符，ptr 存的是 a 的内存地址

    printf("a 的值是: %d\n", a);          // 输出: a 的值是: 42
    printf("a 的地址是: %p\n", (void*)ptr); // 输出: a 的地址是: 0x...（十六进制地址）

    *ptr = 100;  // 通过指针修改 a 的值，C 允许你这么干！

    printf("修改后 a 的值是: %d\n", a);    // 输出: 修改后 a 的值是: 100

    return 0;
}

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

#include <stdio.h>

int main() {
    // sizeof(int) 在不同平台上可能不同
    // 这是 implementation-defined —— 编译器必须告诉你 int 占几个字节
    printf("int 类型的大小是: %zu 字节\n", sizeof(int));
    // 输出（取决于你的编译器）:
    // 在大多数 32 位系统上可能是: 4
    // 在一些老系统上可能是: 2

    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

#include <stdio.h>

int main() {
    int a[3] = {1, 2, 3};
    int *p = &a[0];
    p = p + 5;  // 越界访问数组！这是 undefined behavior
    printf("%d\n", *p);  // 天知道会输出什么！

    return 0;
}

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

#include <stdio.h>

int f(void) { printf("先算 f\n"); return 1; }
int g(void) { printf("先算 g\n"); return 2; }

int add(int x, int y) {
    return x + y;
}

int main(void) {
    // add 的结果 3 是确定的，但"先打印 f 还是先打印 g"是未指定的
    // GCC 通常从右到左，Clang 通常从左到右——两者都完全合法
    printf("结果: %d\n", add(f(), g()));
    return 0;
}

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

/* K&R 风格的函数定义（没有声明参数类型） */
int add(a, b)
int a;
int b;
{
    return a + b;
}

/* 现代 C 风格是这样的： */
int add(int a, int b) {
    return a + b;
}

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

#include <stdio.h>  /* 标准输入输出库 */

/* 这是一个完整的 C89 程序 */
int main(void) {
    char name[50];  /* 字符数组，存字符串用的 */
    int age;

    printf("请输入你的名字: ");  /* 输出到屏幕 */
    scanf("%49s", name);         /* 从键盘读取，%49s 限流防止溢出 */

    printf("请输入你的年龄: ");
    scanf("%d", &age);           /* & 是取地址符 */

    printf("你好，%s！你今年 %d 岁了。\n", name, age);
    /* 输出示例: 你好，张三！你今年 25 岁了。 */

    return 0;
}

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

#include <stdio.h>
#include <iso646.h>  /* 替代运算符拼写 */

int main(void) {
    int a = 5;
    int b = 3;

    if (a > 0 and b > 0) {           /* 等价于 if (a > 0 && b > 0) */
        printf("a 和 b 都是正数\n");
    }

    if (not (a == b)) {              /* 等价于 if (!(a == b)) */
        printf("a 和 b 不相等\n");
    }

    return 0;
}

1
2
3
4
5
6
7
8
9

#include <stdio.h>
#include <wchar.h>

int main(void) {
    wchar_t chinese[] = L"你好，世界";  /* L 前缀表示宽字符串 */
    wprintf(L"%ls\n", chinese);         /* 输出: 你好，世界 */
    return 0;
}

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

#include <stdio.h>
#include <wctype.h>
#include <wchar.h>

int main(void) {
    wint_t ch = L'A';

    if (iswalpha(ch)) {    /* 判断是否是字母 */
        wprintf(L"'%lc' 是一个字母\n", ch);
    }

    if (iswdigit(L'5')) {  /* 判断是否是数字 */
        wprintf(L"'5' 是一个数字\n");
    }

    return 0;
}

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

#include <stdio.h>

int main(void) {
    // 这是单行注释，C99 之前这是非标准的
    int x = 10;  // 行尾注释也行

    /*
     * 这是多行注释，
     * 从 C89 就有了。
     */
    printf("Hello, C99!\n");

    return 0;
}

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

#include <stdio.h>

// inline 建议编译器内联这个函数
inline int max(int a, int b) {
    return (a > b) ? a : b;  /* 三目运算符：条件 ? 值1 : 值2 */
}

int main(void) {
    int a = 5, b = 8;
    int m = max(a, b);  // 编译器可能会直接展开成 m = (a > b) ? a : b;

    printf("最大值是: %d\n", m);  // 输出: 最大值是: 8

    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) {
    int n = 10;

    // 数组大小由变量 n 决定，这是 C99 才支持的
    int arr[n];

    for (int i = 0; i < n; i++) {
        arr[i] = i * i;
    }

    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);  // 输出: 0 1 4 9 16 25 36 49 64 81
    }
    printf("\n");

    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>

int main(void) {
    // C89 风格：变量必须在函数开头声明
    int i;
    int sum = 0;

    // C99 风格：在 for 循环里直接声明
    for (int i = 0; i <= 5; i++) {  // i 只在这个 for 循环里有效
        sum += i;
    }

    printf("1+2+3+4+5 = %d\n", sum);  // 输出: 1+2+3+4+5 = 15

    // C99 还允许在 while 条件里声明（但这不是标准，是 GCC 扩展）
    // int j = 0;
    // while (int k = j++) {  // 有些编译器支持，但标准 C 不允许

    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>
#include <stdint.h>   // 固定宽度整数类型
#include <inttypes.h> // 格式说明符（PRI 和 SCN 宏）

int main(void) {
    int8_t  a = -10;      // 8位有符号整数，范围 -128~127
    int16_t b = 1000;     // 16位有符号整数
    int32_t c = 100000;   // 32位有符号整数
    int64_t d = 1000000;  // 64位有符号整数

    uint8_t  ua = 200;    // 8位无符号整数，范围 0~255
    uint64_t ud = 999999; // 64位无符号整数

    // printf 打印这些类型要用 inttypes.h 定义的格式宏
    printf("a=%" PRId8 ", b=%" PRId16 ", c=%" PRId32 ", d=%" PRId64 "\n",
           a, b, c, d);
    // 输出: a=-10, b=1000, c=100000, d=1000000

    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>
#include <stdbool.h>  // 提供 bool, true, false

int main(void) {
    bool is_coding_fun = true;  // 布尔变量
    bool is_bug_free = false;

    if (is_coding_fun) {
        printf("编程很有趣！\n");  // 输出: 编程很有趣！
    }

    if (!is_bug_free) {
        printf("Bug 是不可避免的...\n");  // 输出: Bug 是不可避免的...
    }

    // bool 类型本质上是个整数，true = 1，false = 0
    printf("sizeof(bool) = %zu\n", sizeof(bool));  // 输出: sizeof(bool) = 1

    return 0;
}

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

#include <stdio.h>

void hello(void) {
    printf("当前函数: %s\n", __func__);  // 输出: 当前函数: hello
}

int main(void) {
    printf("当前函数: %s\n", __func__);  // 输出: 当前函数: main
    hello();
    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>

// _Generic 根据 x 的类型选择打印方式
#define print_type(x) _Generic((x),      \
    int: "int",                          \
    float: "float",                      \
    double: "double",                    \
    char: "char",                        \
    char*: "字符串",                     \
    default: "未知类型"                  \
)

int main(void) {
    int a = 5;
    double b = 3.14;
    char *s = "hello";

    printf("a 的类型是: %s\n", print_type(a));    // int
    printf("b 的类型是: %s\n", print_type(b));    // double
    printf("s 的类型是: %s\n", print_type(s));    // 字符串

    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

#include <stdio.h>
#include <threads.h>

// 线程要执行的函数
int thread_func(void *arg) {
    char *name = (char *)arg;
    for (int i = 0; i < 3; i++) {
        printf("%s 正在运行 (%d)\n", name, i);
        // 休眠 100 毫秒
        struct timespec ts = {0, 100000000};
        thrd_sleep(&ts, NULL);
    }
    return 0;  // 线程返回
}

int main(void) {
    thrd_t t1, t2;

    // 创建两个线程
    thrd_create(&t1, thread_func, "线程A");
    thrd_create(&t2, thread_func, "线程B");

    printf("主线程: 我启动了两个线程！\n");

    // 等待线程结束
    thrd_join(t1, NULL);
    thrd_join(t2, NULL);

    printf("主线程: 两个线程都完成了！\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
25
26
27
28
29
30

#include <stdio.h>
#include <threads.h>
#include <stdatomic.h>

_Atomic int counter = 0;  // 原子变量，多线程安全

int increment(void *arg) {
    (void)arg;  // 忽略参数
    for (int i = 0; i < 1000; i++) {
        atomic_fetch_add(&counter, 1);  // 原子加 1
    }
    return 0;
}

int main(void) {
    thrd_t t1, t2;

    thrd_create(&t1, increment, NULL);
    thrd_create(&t2, increment, NULL);

    thrd_join(t1, NULL);
    thrd_join(t2, NULL);

    // 如果没有原子操作，这个值可能不是 2000（竞态条件）
    // 使用 _Atomic 后，保证是 2000
    printf("counter = %d\n", counter);  // 输出: counter = 2000

    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>

struct Point {
    union {  // 匿名共用体
        struct { int x; int y; };  // 匿名结构体
        int coords[2];              // 也可以用数组访问
    };
};

int main(void) {
    struct Point p;
    p.x = 10;      // 直接访问 x（通过匿名结构体）
    p.y = 20;      // 直接访问 y

    printf("p.x=%d, p.y=%d\n", p.x, p.y);  // p.x=10, p.y=20

    // 也可以通过数组访问同一个内存
    printf("p.coords[0]=%d, p.coords[1]=%d\n", p.coords[0], p.coords[1]);
    // p.coords[0]=10, p.coords[1]=20

    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 <stdalign.h>

struct AlignedStruct {
    _Alignas(16) char data[13];  // 强制 16 字节对齐
};

int main(void) {
    printf("char 对齐: %zu\n", alignof(char));       // 1
    printf("int 对齐: %zu\n", alignof(int));          // 4（通常）
    printf("AlignedStruct 对齐: %zu\n", alignof(struct AlignedStruct)); // 16

    struct AlignedStruct s;
    printf("s 的地址: %p，对齐到: %zu\n",
           (void*)&s, alignof(struct AlignedStruct));

    return 0;
}

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

#include <stdio.h>
#include <assert.h>

// C11 的 _Static_assert（编译时断言）
_Static_assert(sizeof(int) >= 4, "int 必须至少是 4 字节！");

int main(void) {
    // 运行时断言
    int x = 5;
    assert(x > 0);  // 如果 x <= 0，程序会崩溃并报错

    printf("x = %d，断言通过！\n", x);

    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>
#include <stdlib.h>

_Noreturn void fatal_error(const char *msg) {
    printf("严重错误: %s\n", msg);
    exit(1);  // 这个函数不会返回
}

// _Thread_local 放在文件作用域是最常见的用法
_Thread_local int global_tid = 0;

int main(void) {
    // 块作用域下的 _Thread_local 必须再配合 static 或 extern
    static _Thread_local int local_tid = 0;  // 每个线程有自己的 local_tid

    global_tid = 1;
    local_tid = 1;
    printf("当前线程 ID: %d / %d\n", global_tid, local_tid);

    // fatal_error("测试");  // 如果调用，程序会终止

    return 0;
}

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

#include <stdio.h>
#include <uchar.h>

int main(void) {
    // char16_t: UTF-16 字符
    char16_t c16 = u'中';  // 中文字符的 UTF-16 编码

    // char32_t: UTF-32 字符
    char32_t c32 = U'文';  // U 前缀表示 UTF-32

    printf("char16_t 大小: %zu 字节\n", sizeof(char16_t));  // 2
    printf("char32_t 大小: %zu 字节\n", sizeof(char32_t));  // 4

    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

/* 下面这段代码在 C17 下无法编译，必须用 -std=c23 */
#include <stdio.h>

// [[nodiscard]]: 忽略返回值会给出警告（C23 起）
[[nodiscard]] int compute(void) {
    return 42;
}

// [[maybe_unused]]: 抑制未使用变量的警告（C23 起）
void process(int a, [[maybe_unused]] int b) {
    [[maybe_unused]] int temp = a * 2;
    // b 没被使用，但不会有警告
}

// [[deprecated]]: 标记为已废弃（C23 起）
[[deprecated("请使用 new_func 代替")]]
int old_func(void) {
    return 100;
}

// [[fallthrough]]: 用于 switch-case，表示故意穿透（C23 起）
void check(int x) {
    switch (x) {
        case 1:
            printf("case 1\n");
            [[fallthrough]];  // 故意穿透到 case 2
        case 2:
            printf("case 2\n");
            break;
        default:
            printf("其他\n");
            break;
    }
}

int main(void) {
    int result = compute();  // [[nodiscard]] 确保你不会忘记接收返回值
    printf("结果: %d\n", result);

    process(5, 10);
    check(1);

    // old_func();  // 编译时会给出警告：该函数已废弃

    return 0;
}

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

#include <stdio.h>

int main(void) {
    int *p1 = NULL;      // 传统方式
    int *p2 = nullptr;   // C23 的 nullptr

    if (p1 == p2) {
        printf("两者相等，都是空指针\n");
    }

    // nullptr 的类型是 typeof(nullptr)，可以隐式转换为任何指针类型
    double *pd = nullptr;
    char *pc = nullptr;

    printf("nullptr 的大小: %zu\n", sizeof(nullptr));  // 通常和 void* 一样大

    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>

int main(void) {
    int x = 5;
    typeof(x) y = 10;       // y 的类型和 x 一样（int）

    const int cx = 100;
    typeof(cx) cy = 200;    // cy 是 const int

    typeof_unqual(cx) uy = 300;  // uy 是 int（去掉了 const）

    printf("x=%d, y=%d, cx=%d, cy=%d, uy=%d\n", x, y, cx, cy, uy);

    // typeof 最实用的场景：写"参数只求值一次"的泛型宏
    #define MAX(a, b) ({        \
        typeof(a) _a = (a);     \
        typeof(b) _b = (b);     \
        _a > _b ? _a : _b;      \
    })

    int m = MAX(3, 7);
    double dm = MAX(3.14, 2.71);
    printf("MAX(3,7)=%d, MAX(3.14,2.71)=%g\n", m, dm);

    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>

constexpr int ARRAY_SIZE = 100;   // 编译期常量对象
constexpr int DOUBLE_SIZE = ARRAY_SIZE * 2;  // 可以引用另一个 constexpr 常量

// 编译期计算用宏或常量表达式实现，而不是 constexpr 函数
#define SQUARE(x) ((x) * (x))

int main(void) {
    int arr[ARRAY_SIZE];  // 数组大小必须是整型常量表达式
    printf("数组大小: %zu\n", sizeof(arr) / sizeof(arr[0]));  // 100
    printf("DOUBLE_SIZE = %d\n", DOUBLE_SIZE);                // 200

    enum { N = SQUARE(5) };  // 枚举常量，编译期求值
    printf("5 的平方: %d\n", N);  // 25

    // constexpr 对象本身是常量，不能修改
    // ARRAY_SIZE = 200;  // ❌ 编译错误

    return 0;
}

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

#include <stdio.h>

int main(void) {
    int a = 0b1010;   // 二进制 1010 = 十进制 10
    int b = 0B11111111;  // 二进制 11111111 = 十进制 255

    printf("a = %d (二进制 1010)\n", a);   // 10
    printf("b = %d (二进制 11111111)\n", b); // 255

    // 数字分隔符（也支持其他进制）
    int mask = 0b1111'0000'1010;
    printf("mask = %d\n", mask);

    return 0;
}

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

#include <stdio.h>
#include <uchar.h>   /* char8_t 在这里定义 */

int main(void) {
    const char8_t *s = u8"你好，C23!";  // UTF-8 字符串，元素类型是 char8_t
    char8_t c = u8'中';                 // 多字节 UTF-8 字符字面量也是 C23 才有的

    // char8_t 是一个独立的无符号整数类型（通常等价于 unsigned char），不是 char 的别名
    printf("s[0] = 0x%02X\n", (unsigned)s[0]);   // 第一个字节的 UTF-8 编码
    printf("sizeof(char8_t) = %zu\n", sizeof(char8_t));  // 1

    printf("这是一个 UTF-8 字符: %c\n", (char)c);  // 能显示就显示

    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>

[[nodiscard("别忘了检查返回值，可能返回了错误！")]]
int risky_function(void) {
    return -1;
}

int main(void) {
    // 如果直接忽略返回值，编译器会给出警告，包含我们写的理由
    risky_function();

    // 正确做法：
    int result = risky_function();
    if (result < 0) {
        printf("出错了！\n");
    }

    return 0;
}

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

#include <stdio.h>

// 嵌入一个二进制文件的内容（这里假设存在一个 logo.bin）
const unsigned char logo_data[] = {
#embed "logo.bin"
};

int main(void) {
    printf("logo 大小: %zu 字节\n", sizeof(logo_data));
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

/* 如果你在网上看到这种代码，请留意：它不能在任何标准 C 编译器下编译 */
// module;
// export int add(int a, int b) { return a + b; }
// import mymodule;

/* 当下要做"模块化"，仍然是老老实实用头文件 + 多编译单元 */
// mathlib.h   声明
// mathlib.c   实现
// main.c      #include "mathlib.h" 后调用

 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>

int main(void) {
    // _BitInt(N): N 位的带符号整数，范围 -2^(N-1) ~ 2^(N-1)-1
    _BitInt(7) small = 60;      // 7 位，范围 -64 ~ 63，注意别写 100！
    _BitInt(64) big = 12345;    // 64 位

    unsigned _BitInt(128) huge = 1;
    for (int i = 0; i < 100; i++) {
        huge *= 2;  // 2 的 100 次方，128 位无符号足够存
    }

    // _BitInt 类型没有专属的 printf 格式符，必须先转成标准整数类型
    printf("small = %d\n", (int)small);
    printf("big   = %lld\n", (long long)big);

    printf("本实现的 BITINT_MAXWIDTH = %d\n", BITINT_MAXWIDTH);

    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>
#include <stdbit.h>

int main(void) {
    unsigned int x = 0b10110011u;   // 二进制 1011 0011

    printf("x = 0x%x\n", x);

    // 统计前导零和尾随零
    printf("前导零: %u\n", stdc_leading_zeros(x));    // 最高位之前有多少个 0
    printf("尾随零: %u\n", stdc_trailing_zeros(x));   // 最低位之后有多少个 0

    // 统计置位数（1 的个数）
    printf("置位数: %u\n", stdc_count_ones(x));

    // 单例检测（是否只有一个位是 1）
    printf("单例: %s\n", stdc_has_single_bit(x) ? "是" : "否");

    // 表示这个数最少需要多少位
    printf("位宽: %u\n", stdc_bit_width(x));

    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>
#include <limits.h>     /* INT_MAX 在这里 */
#include <stdckdint.h>  /* ckd_add / ckd_sub / ckd_mul */

int main(void) {
    int a = INT_MAX;  // 32 位 int 的最大值，通常是 2147483647

    int result;
    if (ckd_add(&result, a, 1)) {        // 返回 true 表示溢出
        printf("加法溢出！result 里是回绕后的值：%d\n", result);
    } else {
        printf("结果: %d（正常）\n", result);
    }

    if (ckd_mul(&result, a, 2)) {        // 返回 true 表示溢出
        printf("乘法溢出！result 里是回绕后的值：%d\n", result);
    } else {
        printf("结果: %d（正常）\n", result);
    }

    // 减法同样支持
    int b = INT_MIN;
    if (ckd_sub(&result, b, 1)) {
        printf("下溢！\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
25
26
27
28
29
30
31
32
33

#define FEATURE_X 1

#include <stdio.h>

int main(void) {
    // C23 之前要这么写：
    #if defined(FEATURE_X)
        printf("FEATURE_X defined\n");
    #elif defined(FEATURE_Y)
        printf("FEATURE_Y defined\n");
    #else
        printf("两个都没定义\n");
    #endif

    // C23 可以更直观，省掉 defined(...)：
    #ifdef FEATURE_X
        printf("FEATURE_X defined\n");
    #elifdef FEATURE_Y
        printf("FEATURE_Y defined\n");
    #else
        printf("两个都没定义\n");
    #endif

    // #elifndef 则用于"没定义"的分支
    #ifdef FEATURE_X
        printf("有 FEATURE_X\n");
    #elifndef FEATURE_Z
        printf("没有 FEATURE_Z\n");
    #endif

    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 <stdlib.h>

int main(void) {
    char *end;

    // strfromd: double 转字符串
    char buf[50];
    strfromd(buf, sizeof(buf), "%.2f", 3.14159);
    printf("strfromd: %s\n", buf);  // 3.14

    // strfromf: float 转字符串
    strfromf(buf, sizeof(buf), "%.2f", 2.71828f);
    printf("strfromf: %s\n", buf);  // 2.72

    // strfroml: long double 转字符串
    // (用法类似)

    // 反向操作（字符串转数值）的 strtod / strtof / strtold 早就有了（C89/C99）
    double d = strtod("3.14159", &end);
    printf("strtod: %g, 剩余: \"%s\"\n", d, end);

    return 0;
}

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

#define _POSIX_C_SOURCE 200809L   /* 在 glibc 上必须先声明这个宏 */

#include <stdio.h>
#include <stdlib.h>   /* free */
#include <sys/types.h> /* ssize_t */

int main(void) {
    char *line = NULL;      // 必须初始化为 NULL
    size_t len = 0;         // 必须初始化为 0
    ssize_t n;

    printf("请输入内容（Ctrl+D / Ctrl+Z 结束）：\n");

    // getline 会自动分配/扩容内存，读取一整行（含换行符）
    while ((n = getline(&line, &len, stdin)) != -1) {
        printf("读取了 %zd 个字符: %s", n, line);
    }

    free(line);  // 用完要释放内存，这是 getline 的责任转移
    return 0;
}

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

#include <stdio.h>

// C23 之前：
_Static_assert(sizeof(int) >= 4, "int 必须至少是 4 字节");

// C23 开始，也可以：
static_assert(sizeof(int) >= 4, "int 必须至少是 4 字节");  // 不需要下划线
static_assert(sizeof(char) == 1);  // 甚至不需要第二个参数！

int main(void) {
    printf("所有 static_assert 都通过了！\n");
    return 0;
}

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

// 这是一个预览示例，实际 API 可能有所不同
#include <stdio.h>
#include <stdmchar.h>

int main(void) {
    // 假设我们要把 UTF-8 转成 UTF-16
    char8_t utf8_str[] = u8"你好";
    char16_t utf16_buf[20];

    // C29 可能会提供这样的 API（预览）
    // mchar_from_utf8(utf8_str, utf16_buf, sizeof(utf16_buf));

    printf("文本转码库将是 C29 的主要特性\n");

    return 0;
}

1
2
3
4
5
6
7
8

# GCC / Clang 指定 C 标准
gcc -std=c11 myprogram.c -o myprogram    # 用 C11 标准编译
gcc -std=c17 myprogram.c -o myprogram    # 用 C17 标准编译
gcc -std=c23 myprogram.c -o myprogram    # 用 C23 标准编译

# 显示所有警告（包括不符合标准的用法）
gcc -Wall -Wextra -std=c11 myprogram.c -o myprogram

 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

// 用 __STDC_VERSION__ 宏在编译期判断当前标准
// 注意：要四个宏都定义齐全，否则后面 #if IS_CXX 会当成 0 处理，很容易看走眼
#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202311L
    #define IS_C23 1
#else
    #define IS_C23 0
#endif

#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201710L
    #define IS_C17 1
#else
    #define IS_C17 0
#endif

#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L
    #define IS_C11 1
#else
    #define IS_C11 0
#endif

#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
    #define IS_C99 1
#else
    #define IS_C99 0
#endif

#include <stdio.h>

int main(void) {
    printf("正在使用 C");
    #if IS_C23
        printf("23\n");
    #elif IS_C17
        printf("17\n");
    #elif IS_C11
        printf("11\n");
    #elif IS_C99
        printf("99\n");
    #else
        printf("89/90 或更早\n");
    #endif
    return 0;
}

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

// 未定义行为示例
#include <stdio.h>

int main(void) {
    int arr[3] = {1, 2, 3};
    int *p = arr;

    // 数组越界！这是 undefined behavior
    printf("%d\n", arr[1000]);  // 天知道会输出什么

    // 甚至可能：
    // 1. 程序崩溃
    // 2. 输出一个随机数
    // 3. 看起来正常工作（但这是侥幸）
    // 4. 编译器直接把你的程序优化没了！

    return 0;
}

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

#include <stdio.h>

int f(void) { printf("f "); return 1; }
int g(void) { printf("g "); return 2; }

int add(int a, int b) {
    return a + b;
}

int main(void) {
    // add 的返回值一定是 3，但屏幕上先出现 "f " 还是 "g " 未指定
    printf("| 结果=%d\n", add(f(), g()));
    return 0;
}

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

#include <stdio.h>

int counter = 0;
int next(void) { return ++counter; }   // 副作用：修改 counter

int main(void) {
    // next() + next()：哪个先执行未指定，所以结果可能是 1+2 也可能是 2+1
    // 注意：这里"结果都是 3"只是巧合；如果换成 counter*10 + next()，
    // 结果就会随求值顺序变化
    int v = next() * 10 + next();
    printf("v = %d, counter = %d\n", v, counter);
    return 0;
}