/* hello.c */
#include <stdio.h>

int main(void) {
    printf("Hello, C!\n");
    return 0;
}

# 编译 → 运行
gcc hello.c -o hello
./hello                  # 输出：Hello, C!

# 省掉 -o 就得到 a.out
gcc hello.c && ./a.out

#include <stdio.h>   /* ① 搬进 printf 的声明 */

int main(void) {      /* ② 程序入口，不接受参数 */
    printf("Hello, C!\n");  /* ③ 调用；\n 是一个换行符 */
    return 0;          /* ④ 退出码 0 = 成功 */
}

# 验证 ④：退出码真的传出去了
gcc hello.c -o hello && ./hello
echo $?                  # 0；把 return 改成 3 这里就是 3

# ① 编译期：漏分号（注意它指的是上一行）
# hello.c:4:26: error: expected ';' before 'return'

# ② 链接期：main 拼成了 mian
# undefined reference to `main'
# collect2: error: ld returned 1 exit status

/* ③ 运行期：编译零警告，跑起来才炸 */
int *p = NULL;
printf("%d\n", *p);   /* Segmentation fault，退出码 139 */

#include <stdint.h>
#include <stdbool.h>  /* C23 起 bool 内置，此行仅为兼容老编译器 */

int32_t  i = -42;        /* 精确 32 位有符号，跨平台推荐 */
uint64_t u = 1000000ULL;  /* 无符号 64 位，可表示到 ~1.8e19 */
double   d = 3.14159;    /* 8 字节，~15 位有效数字 */
bool     ok = true;

void counter() {
    static int n = 0;    /* 只初始化一次，跨调用保持 */
    n++;
}
const int MAX = 100;     /* 只读；编译期常量用 #define/enum */

int q = 17 / 5;          /* 3，整数除法截断 */
double f = (double)17 / 5; /* 3.4，需强转 */

/* 位操作技巧：设置/清除/读取第 k 位 */
flags |= (1u << k);         /* 置位（用 1u：1<<31 是符号位 UB） */
flags &= ~(1u << k);        /* 清位 */
int bit = (flags >> k) & 1; /* 取位 */

switch (grade) {
    case 'A': puts("优"); break; /* break 防 fall-through */
    default: puts("其他");
}
int max = (a > b) ? a : b;  /* 三目运算符 */

/* ① 有符号 vs 无符号：有符号被转成无符号 */
int i = -1;
if (i < 1u)              /* 假！i 被当成 4294967295 */
    puts("不会执行");

/* 高发变形：和 sizeof/strlen（size_t 无符号）比较 */
size_t len = strlen(s);   /* 先存下来：既统一了符号，也避免每轮重扫 O(n²) */
for (size_t k = 0; k < len; k++) { }

/* ② 整型提升：char/short 运算前升成 int */
char a = 100, b = 100;
int p = a * b;            /* 10000：先升 int 再乘，不会溢出 char */

/* ③ 窄化：高位被截断 */
int big = 300;
unsigned char uc = big;  /* 44：300 % 256，高位丢失 */

/* 混合运算：结果向更宽/浮点的一方靠 */
double avg = sum / (double)n; /* 强转一个操作数，避免整数除法截断 */

/* for：次数已知；i 声明在循环头，作用域仅限循环内 */
for (int i = 0; i < n; i++)   /* 半开区间 [0, n)：标准写法 */
    sum += i;                    /* 纯标量累加；数组下标 a[i] 见下一卡 */

/* do-while：至少执行一次——菜单/重试的标配 */
int choice;
do {
    show_menu();
    choice = read_choice();
} while (choice != 0);          /* 注意结尾分号 */

/* break 找到即止，continue 跳过本轮 */
for (int i = 0; i < n; i++) {
    if (a[i] < 0) continue;    /* 负数不处理 */
    if (a[i] == key) { pos = i; break; }
}

/* 无符号数倒序遍历的安全写法：i-- 放进条件 */
for (size_t i = n; i-- > 0; )
    process(a[i]);

int arr[5] = {1, 2, 3};      /* 后两个补 0 */
int grid[2][3] = {{1,2,3},{4,5,6}};

/* 传数组必须带长度（decay 成指针）*/
void print_n(int *a, int n) {
    for (int i = 0; i < n; i++) printf("%d ", a[i]);
}

/* 字符串 = 以 '\0' 结尾的 char 数组 */
char s[32] = "hello";
size_t len = strlen(s);          /* 5，不含 '\0' */

/* 安全拷贝：snprintf 一定补 '\0'，永不越界 */
char dst[32];
const char *src = "hello, world";
snprintf(dst, sizeof(dst), "%s", src); /* 优于 strncpy：截断时它仍补 '\0' */

printf("[%5d] [%-5d] [%05d]\n", 42, 42, 42);
/* [   42] [42   ] [00042]：右对齐 / 左对齐 / 补零 */

printf("%+d %#x %.3f %g\n", 42, 255, 3.14159, 0.000031);
/* +42 0xff 3.142 3.1e-05 */

printf("%.3s|%*d|\n", "hello", 6, 42);
/* hel|    42|：精度截断字符串，宽度 6 由实参传入 */

long long big = 1LL << 40;
printf("%lld %zu %p\n", big, sizeof(big), (void*)&big);

/* 拼字符串用 snprintf：永不越界，返回值可测截断 */
char path[32];
int need = snprintf(path, sizeof(path), "user-%d.log", id);
if (need >= (int)sizeof(path)) { /* 结果被截断了 */ }

int a; char op; double b;
/* " %c" 的前导空格：跳过残留换行再读运算符 */
if (scanf("%d %c %lf", &a, &op, &b) != 3) {
    /* 输入不合法：非法字符还留在流里，须先清理 */
}

/* scanset：读到行尾为止（类似读整行），务必限宽 */
char name[64];
scanf(" %63[^\n]", name);

/* 星号 = 匹配但丢弃：跳过第一列，只取第二列 */
int age;
scanf("%*s %d", &age);

/* 经典过滤器：把 stdin 逐字符搬到 stdout，直到 EOF */
int c;                     /* 必须 int：char 装不下 EOF */
while ((c = getchar()) != EOF)
    putchar(c);

/* 同一骨架顺手改成行数统计（wc -l 的核心） */
long lines = 0;
while ((c = getchar()) != EOF)
    if (c == '\n') lines++;

/* 不带换行的提示语：手动刷出，保证立刻可见 */
printf("请输入名字： ");
fflush(stdout);

/* 交互读整数的标准姿势：失败重新提示，绝不死循环 */
char line[64];
long v;
for (;;) {
    printf("输入端口号： "); fflush(stdout);
    if (!fgets(line, sizeof(line), stdin)) return 1; /* EOF */

    char *end;
    errno = 0;
    v = strtol(line, &end, 10);
    if (end != line && errno == 0
        && (*end == '\n' || *end == '\0')) break; /* 合法 */
    puts("不是合法整数，请重试");
}   /* 非法输入只污染 line 这个局部数组，stdin 始终干净 */

FILE *fp = fopen("data.txt", "r");
if (!fp) { perror("fopen"); return 1; }

char line[256];
while (fgets(line, sizeof(line), fp))    // 返回 NULL 即结束
    fputs(line, stdout);
fclose(fp);

/* 写文本 + 立刻落盘 */
FILE *out = fopen("log.txt", "a");       // 追加，不清空原文件
fprintf(out, "%s = %d\n", key, val);
fflush(out);                             // 不等缓冲满就写出
fclose(out);

/* 二进制：整条记录读写 + 随机定位 */
FILE *bin = fopen("rec.bin", "wb");      // wb：二进制，Windows 上别漏 b
fwrite(&rec, sizeof(Record), 1, bin);
fclose(bin);

bin = fopen("rec.bin", "rb");
fseek(bin, 2 * sizeof(Record), SEEK_SET); // 跳到第 3 条记录
if (fread(&rec, sizeof(Record), 1, bin) != 1)  // 检查读到的条数！
    fprintf(stderr, "读取不足\n");
long pos = ftell(bin);                   // 当前字节偏移
fclose(bin);

/* 值传递：传指针才能改调用方的变量 */
void swap(int *a, int *b) {
    int t = *a; *a = *b; *b = t; /* *a 解引用 */
}
swap(&x, &y);                  /* &x 取地址 */

/* 递归：先写出口（终止条件），再写递推 */
long long factorial(int n) {
    if (n <= 1) return 1;     /* 出口：缺了它就无限递归 */
    return n * factorial(n-1);
}

int main(int argc, char *argv[]) {
    printf("程序名：%s\n", argv[0]);
    printf("收到 %d 个参数\n", argc - 1);

    /* 逐个遍历真正的参数（跳过 argv[0]）*/
    for (int i = 1; i < argc; i++)
        printf("  argv[%d] = %s\n", i, argv[i]);

    /* 参数是字符串，要数字得自己转 */
    if (argc < 2) {
        fprintf(stderr, "用法：%s <端口>\n", argv[0]);
        return 1;              /* 非 0 退出码 = 失败 */
    }
    long port = strtol(argv[1], NULL, 10);
    printf("端口 = %ld\n", port);
    return 0;                  /* 0 = 成功 */
}

typedef struct {
    char name[32];
    int  age;
} User;                       /* typedef 免去每次写 struct */

User u = { "Alice", 30 };
User *p = &u;
printf("%s", p->name);        /* 指针用 -> 访问成员 */

/* union：成员共享内存，同时只有一个有效 */
union Value { int i; float f; char *s; };

/* enum：命名整数常量 */
enum Color { RED, GREEN = 5, BLUE }; /* 0, 5, 6 */

int  n = 42;
int *p = &n;        /* p 存 n 的地址 */
*p = 100;            /* 通过指针改 n */

int arr[] = {10,20,30};
int *q = arr;       /* 指向 arr[0] */
q++;                /* 前进 sizeof(int)，指向 arr[1] */
printf("%d", q[1]);  /* 30，等价 *(q+1) */

/* const 四组合：const 在 * 左锁数据，右锁指针 */
const int *cp;     /* 不能改 *cp，能改 cp */
int * const pc = &n;  /* 能改 *pc，不能改 pc */

/* void*：通用指针，泛型 swap */
void gswap(void *a, void *b, size_t sz) {
    char tmp[sz];           /* C99 VLA */
    memcpy(tmp, a, sz);
    memcpy(a, b, sz);
    memcpy(b, tmp, sz);
}
gswap(&ia, &ib, sizeof(int));   /* int 可 */
gswap(&da, &db, sizeof(double)); /* double 也可 */

/* NULL 解引用前必须判空 */
if (p != NULL) *p = 5;

int *a = malloc(n * sizeof(int));
if (!a) { perror("malloc"); return 1; } /* 必查 */

/* realloc：先存到临时指针，成功再覆盖 */
int *tmp = realloc(a, new_n * sizeof(int));
if (!tmp) { free(a); return 1; } /* 原 a 仍有效 */
a = tmp;

free(a);
a = NULL;   /* 好习惯：释放后置 NULL，避免悬空 */

/* ❌ 悬空指针 */
free(p);
*p = 5;           /* UB！内存已归还 */
p = NULL;          /* ✅ free 后立即置 NULL */

/* ❌ 返回局部变量地址 */
int* bad() {
    int x = 42;
    return &x;     /* x 在函数返回后销毁 */
}                  /* 应返回 malloc 的指针或用输出参数 */

typedef int (*BinOp)(int, int); /* 简化声明 */
int add(int a, int b) { return a + b; }

BinOp ops[] = { add, sub, mul };    /* 跳转表 */
printf("%d", ops[0](2, 3));      /* 5 */

/* qsort 的比较函数（升序）*/
int cmp(const void *a, const void *b) {
    int x = *(const int*)a, y = *(const int*)b;
    return (x > y) - (x < y); /* 不用 a-b 减法：大值相减会溢出 UB */
}
qsort(arr, n, sizeof(int), cmp);

int load(const char *path) {
    FILE  *fp  = NULL;
    char  *buf = NULL;
    int    rc  = -1;         /* 默认失败 */

    fp = fopen(path, "rb");
    if (!fp)  goto done;      /* 还没申请 buf，直接去清理 */

    buf = malloc(4096);
    if (!buf) goto done;      /* fp 已开，清理段会关掉它 */

    if (fread(buf, 1, 4096, fp) == 0) goto done;
    rc = 0;                    /* 走到这里才算成功 */

done:                            /* 统一出口：按相反顺序回滚，判空后释放 */
    free(buf);                /* free(NULL) 安全 */
    if (fp) fclose(fp);
    return rc;
}

int g_init = 10;        /* Data 段 */
int g_zero;             /* BSS 段，自动清零 */
const char *s = "hi";   /* "hi" 在 Text（只读）*/

void foo() {
    int  local = 42;     /* Stack：返回即销毁 */
    int *heap = malloc(4); /* heap 指针在栈，*heap 在堆 */
    free(heap);
}

/* 高地址 ↑ Stack | ... | Heap | BSS | Data | Text ↓ 低地址 */

#include <stddef.h>   /* offsetof */

struct Bad  { char a; int b; char c; }; /* 常见 12 字节：a 后填 3、c 后填 3 */
struct Good { int b; char a; char c; }; /* 紧凑 8 字节：同样字段，换个顺序 */

printf("%zu %zu\n", sizeof(struct Bad), sizeof(struct Good));
printf("b 偏移 %zu\n", offsetof(struct Good, b));

/* 位域：把标志压进按位的空间 */
struct Flags {
    unsigned visible : 1;   /* 只占 1 位 */
    unsigned level   : 3;   /* 占 3 位，表示 0-7 */
};

/* C11 显式对齐（需 <stdalign.h>）*/
alignas(16) char buf[64]; /* buf 起始地址是 16 的倍数 */

#define MAX(a, b)  ((a) > (b) ? (a) : (b)) /* 括号必加 */
#define SQ(x)     ((x) * (x))

/* 可变参数宏做日志（##__VA_ARGS__ 是 GNU 扩展；C23 标准写法用 __VA_OPT__(,)） */
#define LOG(fmt, ...) \
    fprintf(stderr, "[%s:%d] " fmt "\n", \
            __FILE__, __LINE__, ##__VA_ARGS__)

/* 头文件保护：防重复包含 */
#ifndef MYLIB_H
#define MYLIB_H
/* ... 声明 ... */
#endif   /* 或用 #pragma once */

/* 单一数据源：列表只写这一次 */
#define COLORS(X)  X(RED) X(GREEN) X(BLUE)

/* 两个「生成器」宏，轮流当上面的 X */
#define GEN_ENUM(name)  name,
#define GEN_STR(name)   #name,

enum Color { COLORS(GEN_ENUM) };              /* → RED, GREEN, BLUE, */
const char *color_name[] = { COLORS(GEN_STR) };  /* → "RED","GREEN","BLUE", */

printf("%s\n", color_name[GREEN]);          /* 打印 "GREEN" */

/* 加一个颜色只改 COLORS 那行，enum 与字符串表一起变 */
/* 大列表常放进单独 .def 文件、反复 #include：
     #define X(name) ...  #include "colors.def"  #undef X */

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

/* 求任意个 int 之和：第一个具名参数 count 说明有几个 */
int sum(int count, ...) {
    va_list ap;
    va_start(ap, count);     /* 锚在最后一个具名参数上 */
    int total = 0;
    for (int i = 0; i < count; i++)
        total += va_arg(ap, int); /* 按 int 逐个取 */
    va_end(ap);             /* 必须收尾 */
    return total;
}
sum(3, 10, 20, 30);      /* 60 */

/* 自写日志：把可变参数原样转发给 vfprintf */
void mylog(const char *fmt, ...) {
    va_list ap;
    va_start(ap, fmt);
    fprintf(stderr, "[LOG] ");
    vfprintf(stderr, fmt, ap); /* v 版本吃 va_list */
    va_end(ap);
}
mylog("port=%d host=%s\n", 8080, "localhost");

// val2.c
double value = 3.14;

// use2.c
extern int value;
printf("%d\n", value);

编译链接 exit=0        <- 一条警告都没有
运行输出: 1374389535   <- 把 double 的前四个字节当 int 读了

# 分步编译（理解原理）
gcc -c math.c -o math.o      # 编译为目标文件
gcc -c main.c -o main.o
gcc math.o main.o -o app     # 链接

# 一步到位 + 开启警告（小项目）
gcc *.c -o app -Wall -Wextra -std=c23

目标(target)： 依赖(prerequisites)
<Tab>命令(recipe)

# Makefile —— 自动收集源文件 + 自动头文件依赖
CC     := gcc
CFLAGS := -Wall -Wextra -std=c23 -O2 -MMD -MP   # -MMD -MP：顺带生成 .d 依赖
SRCS   := $(wildcard *.c)                        # 目录下所有 .c
OBJS   := $(patsubst %.c,%.o,$(SRCS))            # .c 列表 → .o 列表

# 第一条规则 = 默认目标：可执行文件依赖全部 .o
app: $(OBJS)
	$(CC) $(CFLAGS) $^ -o $@       # $^=全部 .o  $@=app

# 模式规则：每个 .o 由同名 .c 编出
%.o: %.c
	$(CC) $(CFLAGS) -c $< -o $@    # $<=对应的那个 .c

# 伪目标：不产出同名文件，只是一组动作
.PHONY: clean
clean:
	rm -f $(OBJS) $(OBJS:.o=.d) app

# 引入自动生成的头文件依赖（前缀 - 忽略首次尚不存在）
-include $(OBJS:.o=.d)

# make       默认构建 app（只重编改动过的文件）
# make -j8   8 路并行编译，吃满多核
# make -n    dry-run：只打印将执行的命令、不真正运行
# make -B    强制全量重建   make clean  清理

# CMakeLists.txt —— 只描述「要什么」，不写平台细节
cmake_minimum_required(VERSION 3.21)   # C_STANDARD 23 需 3.21+
project(myapp LANGUAGES C)

set(CMAKE_C_STANDARD 23)             # 这是 C 项目：用 C_ 而非 CXX_
set(CMAKE_C_STANDARD_REQUIRED ON)

# 一组源文件先编成库，再让可执行文件用它
add_library(core src/math.c src/util.c)
target_include_directories(core PUBLIC include)   # PUBLIC：用 core 者自动获得头目录

add_executable(app src/main.c)
target_link_libraries(app PRIVATE core)          # 传递性：app 自动拿到 core 的公开属性

# 找系统依赖，跨平台写法一致
find_package(Threads REQUIRED)
target_link_libraries(app PRIVATE Threads::Threads)

# 配置并构建：
# cmake -B build -G Ninja -DCMAKE_BUILD_TYPE=Release
# cmake --build build -j
# ctest --test-dir build      运行 add_test 注册的测试

# 系统包管理器 + pkg-config（最常见）
sudo apt install libcurl4-openssl-dev   # 装的是 -dev 包（带头文件！）
gcc app.c $(pkg-config --cflags --libs libcurl) -o app
# --cflags 吐 -I 路径，--libs 吐 -lcurl 等链接旗标

# Makefile 里接 pkg-config
# CFLAGS += $(shell pkg-config --cflags libcurl)
# LDLIBS += $(shell pkg-config --libs   libcurl)

# vendor：源码直接进仓库，编进自己的构建
# third_party/cJSON/cJSON.c → 加进 SRC 列表一起编

/* 复合字面量：匿名对象直接用 */
Point p = (Point){ .x = 3, .y = 4 };
int *a = (int[]){ 1, 2, 3 };

/* 指定初始化器：其余自动为 0 */
int sparse[10] = { [0]=1, [9]=9 };

/* static inline：比宏安全，消除调用开销 */
static inline int clamp(int v, int lo, int hi) {
    return v < lo ? lo : (v > hi ? hi : v);
}

/* volatile：值会被「程序之外」改变，不能缓存进寄存器 */
volatile int *reg = (int *)0x40000000; /* 硬件寄存器地址 */
while (*reg == 0) { }     /* 每次都真的去读；去掉 volatile 可能死循环 */

volatile sig_atomic_t quit = 0; /* 信号处理函数会改它（见信号卡）*/

/* restrict：承诺 dst/src 不重叠，编译器可激进优化 */
void copy(int *restrict dst,
          const int *restrict src, size_t n) {
    for (size_t i = 0; i < n; i++)
        dst[i] = src[i];         /* 保证不重叠才敢这样优化 */
}

/* _Generic：按类型选择，做类型安全的泛型 abs */
#define gen_abs(x) _Generic((x), \
    int:       abs(x),  \
    long:      labs(x), \
    float:     fabsf(x),\
    double:    fabs(x))

gen_abs(-5);     /* 选 abs */
gen_abs(-3.14);  /* 选 fabs */

/* C11 编译期断言 */
_Static_assert(sizeof(int) == 4, "需要 32 位 int");

/* gcc 15 默认就是 C23，下面不加 -std 直接编 */
#include <stdio.h>
#include <stddef.h>            /* unreachable() */

constexpr int    SIZE = 16;    /* 有类型的编译期常量，胜过 #define */
constexpr double GAIN = 1.5;   /* enum 做不到：常量可以是 double */

int parity(int x) {
    switch (x & 1) {
        case 0: return 0;
        case 1: return 1;
        default: unreachable();  /* 到不了；走到了就是 UB */
    }
}

int main(void) {
    auto  n    = SIZE * 2;         /* 推导为 int，无需写类型 */
    int  *p    = nullptr;          /* 有自己类型的空指针，不再靠 NULL 宏 */
    int   mask = 0b1010'1100;      /* 二进制字面量 + 数字分隔符 */
    int   big  = 1'000'000;        /* ' 只为可读，不改变值 */
    _BitInt(12) reg = 0xABC;       /* 精确 12 位：寄存器/协议字段 */

    printf("%b\n", mask);          /* %b：二进制输出，与 0b 对称 */
    printf("%d %d %d %p %.1f\n", n, big, parity(mask), (void *)p, GAIN);
    (void)reg;
    return 0;
}

# 编译期：警告拉满 + 调试信息
gcc main.c -Wall -Wextra -Werror -g -O0 -o app

# 运行期检查：内存 + 未定义行为
gcc main.c -fsanitize=address,undefined -g -o app
valgrind --leak-check=full ./app

# gdb 常用：break / run / next / step / print / bt
gdb ./app

#include <unistd.h>
#include <stdio.h>

int main(void) {
    pid_t pid = fork();          /* 从这一行开始一分为二 */
    if (pid < 0) { perror("fork"); return 1; }

    if (pid == 0)
        printf("子进程： 我的 pid=%d\n", getpid());
    else
        printf("父进程： 子进程 pid=%d\n", pid);
    return 0;                    /* 两个进程都会执行到这里 */
}

#include <unistd.h>
#include <sys/wait.h>

pid_t pid = fork();
if (pid == 0) {                    /* 子进程 */
    char *argv[] = { "ls", "-l", NULL };
    execvp("ls", argv);             /* 成功则不再返回 */
    perror("execvp");              /* 只有 exec 失败才会走到这 */
    _exit(127);
}
int status;
waitpid(pid, &status, 0);          /* 阻塞等这个子进程 */
if (WIFEXITED(status))
    printf("子进程退出码 %d\n", WEXITSTATUS(status));

#include <unistd.h>
#include <signal.h>

/* 1) 管道：父写、子读 */
int fd[2];
pipe(fd);
if (fork() == 0) {              /* 子：关掉写端，从读端收 */
    close(fd[1]);
    char buf[64];
    int n = read(fd[0], buf, sizeof buf);
    write(1, buf, n);            /* 原样打到标准输出 */
} else {                          /* 父：关掉读端，往写端发 */
    close(fd[0]);
    write(fd[1], "hi child\n", 9);
}

/* 2) 信号：收到 kill 时优雅退出 */
volatile sig_atomic_t quit = 0;
void on_term(int s) { quit = 1; }   /* 只置标志，收尾留给主循环 */
signal(SIGTERM, on_term);

#include <pthread.h>
#include <stdio.h>

long counter = 0;                  /* 被两个线程共享 */

void *work(void *arg) {
    for (int i = 0; i < 1000000; i++)
        counter++;                   /* 非原子：读→加→写三步，会丢更新 */
    return NULL;
}

int main(void) {
    pthread_t t1, t2;
    pthread_create(&t1, NULL, work, NULL);
    pthread_create(&t2, NULL, work, NULL);
    pthread_join(t1, NULL);
    pthread_join(t2, NULL);
    printf("counter=%ld (期望 2000000)\n", counter);
    return 0;                    /* 几乎总是小于 200 万 */
}

#include <pthread.h>

pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t  ready_cv = PTHREAD_COND_INITIALIZER;
int ready = 0;

void *consumer(void *a) {
    pthread_mutex_lock(&mtx);
    while (!ready)                    /* while 而非 if:防虚假唤醒 */
        pthread_cond_wait(&ready_cv, &mtx);  /* 放锁+睡，醒来自动重新持锁 */
    /* ... 安全地消费共享数据 ... */
    pthread_mutex_unlock(&mtx);
    return NULL;
}

void *producer(void *a) {
    pthread_mutex_lock(&mtx);
    ready = 1;
    pthread_cond_signal(&ready_cv);      /* 唤醒等待的消费者 */
    pthread_mutex_unlock(&mtx);
    return NULL;
}

#include <stdatomic.h>
#include <pthread.h>

atomic_long counter = 0;

void *work(void *a) {
    for (int i = 0; i < 1000000; i++)
        atomic_fetch_add(&counter, 1);  /* 原子自增，无需锁 */
    return NULL;
}
/* 这次 counter 精确等于 200 万——原子操作补回了上一张卡丢掉的更新 */

/* 默认选择：snprintf——永远补 \0，还能检测截断 */
char dst[64];
int need = snprintf(dst, sizeof dst, "%s/%s", dir, name);
if (need < 0 || (size_t)need >= sizeof dst) {
    /* 被截断了：need 是「本该写入」的长度，不是实际写入的 */
    return -1;
}

/* 确定装得下时才用 strcpy：这里长度是自己算的 */
char *copy = malloc(strlen(src) + 1);
if (copy) strcpy(copy, src);

/* 二进制数据用 memcpy，不关心 \0；重叠区域用 memmove */
memcpy(buf, packet, payload_len);

/* 非要用 strncpy，必须自己补结尾符 */
strncpy(dst, src, sizeof dst);
dst[sizeof dst - 1] = '\0';      /* 少了这行就可能不是字符串 */

/* 循环拼接：别用 strcat，自己推进偏移 */
size_t off = 0;
for (int i = 0; i < n; i++) {
    int w = snprintf(out + off, sizeof out - off, "%s,", item[i]);
    if (w < 0 || (size_t)w >= sizeof out - off) break;   /* 满了 */
    off += (size_t)w;
}

/* 比较：只看符号，别拿返回值和 -1 比 */
if (strcmp(a, b) < 0) { }        /* 对 */
if (strcmp(a, b) == -1) { }      /* 错：不保证是 -1 */

第一次 localtime 记下  1970
第二次调用之后，同一个指针读到  1999
两个指针是否同一地址: 是

/* ① 调用方负责 free */
char *s = strdup(name);
if (!s) return -1;
/* ... 用 s ... */
free(s);

/* ② 指向入参内部：不用 free，但寿命跟着 line 走 */
char *p = strchr(line, ':');
if (p) *p = '\0';            /* 改的是 line 自己 */

/* ③ 静态缓冲：下一次调用就没了——立刻拷走 */
struct tm snapshot = *localtime(&t);   /* 拷值，不存指针 */

/* 或者用可重入版，缓冲区由你提供（POSIX） */
struct tm buf;
localtime_r(&t, &buf);

/* strtok 会破坏原串：先拷一份再切 */
char line2[256];
snprintf(line2, sizeof line2, "%s", original);
char *save;                          /* strtok_r 的状态由你保存 */
for (char *tok = strtok_r(line2, ",", &save);
     tok;
     tok = strtok_r(NULL, ",", &save)) {
    /* 处理 tok */
}

/* 自己的函数：把约定写在名字和注释里 */
/* 返回新分配的字符串；调用方负责 free */
char *config_get_new(const char *key);

/* 更好：让调用方给缓冲区，没有所有权转移 */
int config_get(const char *key, char *out, size_t cap);

#include <stdlib.h>

/* 整数比较：三态惯用法，无溢出风险 */
static int cmp_int(const void *a, const void *b) {
    int x = *(const int *)a, y = *(const int *)b;
    return (x > y) - (x < y);        /* 不要写 x - y */
}

/* 字符串数组：元素本身是 char*，所以参数是 char** */
static int cmp_str(const void *a, const void *b) {
    return strcmp(*(const char **)a, *(const char **)b);
}

/* 多字段 + 保稳定：把原始下标当最后一个比较字段 */
struct rec { int key; int idx; };
static int cmp_rec(const void *a, const void *b) {
    const struct rec *x = a, *y = b;
    if (x->key != y->key) return (x->key > y->key) - (x->key < y->key);
    return (x->idx > y->idx) - (x->idx < y->idx);   /* 打破平局 */
}

int a[] = {5, 1, 4, 2, 3};
size_t n = sizeof a / sizeof a[0];

qsort(a, n, sizeof a[0], cmp_int);          /* 必须先排序 */

int key = 4;
int *hit = bsearch(&key, a, n, sizeof a[0], cmp_int);
if (hit) { /* 命中，hit 指向数组里那个元素 */ }

#include <stdlib.h>
#include <errno.h>

/* 把字符串严格解析成 long；成功返 0，失败返 -1 */
int parse_long(const char *s, long *out) {
    char *end;
    errno = 0;                       /* 判据② 的前提 */
    long v = strtol(s, &end, 10);      /* 明确写 10，别传 0 */

    if (end == s)          return -1;   /* ① 一个数字都没有 */
    if (errno == ERANGE)   return -1;   /* ② 溢出 */
    while (*end == ' ' || *end == '\n') end++;   /* 容忍尾部空白 */
    if (*end != '\0')       return -1;   /* ③ 还有别的垃圾 */

    *out = v;
    return 0;
}

/* 要 int 就再加一道范围检查——strtol 只保证 long 的范围 */
int parse_int(const char *s, int *out) {
    long v;
    if (parse_long(s, &v) != 0) return -1;
    if (v < INT_MIN || v > INT_MAX) return -1;
    *out = (int)v;
    return 0;
}

/* 反例：这两行是等价的「我不在乎对不对」 */
int n1 = atoi(argv[1]);              /* 失败也返回 0 */
int n2 = atoi("abc");                 /* 同样是 0 */

/* rand：可以用在哪 */
srand((unsigned)time(NULL));       /* 一秒内多次启动会撞种子 */
int dice = rand() % 6 + 1;         /* 游戏掷骰子：偏差可忽略 */

/* 安全用途：别用 rand，走系统的随机源 */
/* #include <sys/random.h> */
unsigned char token[32];
getrandom(token, sizeof token, 0);   /* Linux；或读 /dev/urandom */

/* 文本：UTF-8 存在普通 char 里，别碰 wchar_t */
const char *name = "张三";            /* 6 字节，2 个字符 */
strlen(name);                        /* 6：字节数，不是字符数 */

/* 解析固定格式前，把数值 locale 钉死 */
setlocale(LC_NUMERIC, "C");          /* 只在 main 里调 */

/* 信号处理函数：只设标志，别干活 */
static volatile sig_atomic_t should_stop = 0;

static void on_sigint(int sig) {
    (void)sig;
    should_stop = 1;                  /* 唯一安全的操作 */
}

while (!should_stop) {
    /* 真正的收尾工作放在这里做，不在处理函数里 */
}

/* —— 格式化输出 —— */
/* 格式化输出到 stdout｜传 格式串+实参｜成功返写出的字符数｜出错返负数 */
printf("%d 项\n", n);
/* 格式化输出到指定流｜传 流+格式串+实参｜成功返写出字符数｜出错返负数 */
fprintf(stderr, "错误： %s\n", msg);
char buf[64];
/* 安全格式化到缓冲｜传 缓冲+容量n+格式｜成功返本应写入长度（≥n 即被截断，最多写 n-1 字符补 '\0'）｜编码出错返负数 */
int need = snprintf(buf, sizeof buf, "u-%d", id);
/* 格式化到缓冲（不限长、易溢出，优先 snprintf）｜传 缓冲+格式｜成功返写出字符数｜出错返负数 */
sprintf(buf, "%d", id);
/* snprintf 的 va_list 版（自封装日志用，见「布尔·变参」卡）｜传 缓冲+容量+格式+va_list｜成功返本应长度｜出错返负数 */
vsnprintf(buf, sizeof buf, fmt, ap);
/* fprintf 的 va_list 版｜传 流+格式+va_list｜成功返写出字符数｜出错返负数 */
vfprintf(stderr, fmt, ap);

/* —— 格式化输入 —— */
int a, b;
/* 从 stdin 按格式读｜传 格式串+目标地址｜成功返匹配并赋值的项数（应 ==2）｜到 EOF 返 EOF */
scanf("%d %d", &a, &b);
/* 从字符串按格式解析｜传 源串+格式+目标地址｜成功返匹配项数｜首项前即失败返 EOF */
sscanf("3,5", "%d,%d", &a, &b);
/* 从流按格式读｜传 流+格式+目标地址｜成功返匹配项数｜到 EOF/出错返 EOF */
fscanf(fp, "%d", &a);

/* —— 文件打开与整块读写 —— */
/* 打开文件｜传 路径+模式(r/w/a，+b 二进制)｜成功返 FILE*｜失败返 NULL */
FILE *fp = fopen("rec.bin", "rb");
/* 按 errno 打印「前缀: 描述」到 stderr｜传 前缀串｜无返回值 */
if (!fp) { perror("fopen"); return 1; }
/* 按块读｜传 缓冲+单块大小+块数+流｜成功返读到的块数｜少于请求数即遇 EOF/错误 */
size_t got = fread(rec, sizeof *rec, 10, fp);
/* 按块写｜传 源+单块大小+块数+流｜成功返写出的块数｜少于请求数即写出错 */
fwrite(rec, sizeof *rec, got, fp);
/* 关闭并刷新流｜传 流｜成功返 0｜出错返 EOF */
fclose(fp);

/* —— 行与字符读写 —— */
char line[256];
/* 读一行｜传 缓冲+容量n+流｜成功返 line（最多读 n-1 字符含换行、补 '\0'）｜EOF/错误返 NULL */
fgets(line, sizeof line, stdin);
/* 写字符串到流（不含 '\0'、不换行）｜传 字符串+流｜成功返非负｜出错返 EOF */
fputs(line, stdout);
/* 写字符串到 stdout 并自动补换行｜传 字符串｜成功返非负｜出错返 EOF */
puts("done");
/* 从 stdin 读一个字符（=fgetc(stdin)，须用 int 接）｜无参｜成功返字符 0-255｜到尾/出错返 EOF */
int ch = getchar();
/* 写一个字符到 stdout（=fputc(ch,stdout)）｜传 字符｜成功返该字符｜出错返 EOF */
putchar(ch);
/* 从流读一个字符（getc 是其宏版）｜传 流｜成功返字符｜到尾/出错返 EOF */
ch = fgetc(fp);
/* 向流写一个字符（putc 是其宏版）｜传 字符+流｜成功返该字符｜出错返 EOF */
fputc(ch, fp);
/* 退回一个字符到流供下次读｜传 字符+流｜成功返该字符｜失败返 EOF（至少保证退 1 个） */
ungetc(ch, fp);

/* —— 刷新、定位与错误 —— */
/* 刷新流缓冲｜传 流(NULL=所有输出流)｜成功返 0｜出错返 EOF */
fflush(stdout);
/* 设置流缓冲模式｜传 流+缓冲区+模式+大小（_IONBF 无/_IOLBF 行/_IOFBF 全）｜成功返 0｜失败返非 0 */
setvbuf(stdout, NULL, _IONBF, 0);
/* 移动读写位置｜传 流+偏移+基准(SEEK_SET/CUR/END)｜成功返 0｜失败返 -1 */
fseek(fp, 0, SEEK_END);
/* 取当前读写位置（字节偏移，此处即文件大小）｜传 流｜成功返偏移量｜出错返 -1L */
long sz = ftell(fp);
/* 回到流开头并清错误标志（=fseek(fp,0,SEEK_SET)）｜传 流｜无返回值 */
rewind(fp);
/* 测流是否到文件尾（区分「读完」与「读错」）｜传 流｜到尾返非 0 否则 0 */
if (feof(fp)) { }
/* 测流是否出错｜传 流｜出错返非 0 否则 0 */
if (ferror(fp)) { }
/* 清流的 EOF 与出错标志｜传 流｜无返回值 */
clearerr(fp);
/* 删除文件（rename("a","b") 改名/移动）｜传 路径｜成功返 0｜失败返非 0 */
remove("old.tmp");

/* —— 动态内存 —— */
/* 分配未初始化内存｜传 字节数｜成功返内存指针｜失败返 NULL */
int *a = malloc(n * sizeof *a);
/* 分配并清零（内置 n×size 溢出检查）｜传 元素个数+单块大小｜成功返内存指针｜失败返 NULL */
int *b = calloc(n, sizeof *b);
/* 调整已分配块大小、可能搬迁｜传 原指针+新字节数｜成功返新指针｜失败返 NULL 且原块仍有效 */
a = realloc(a, 2*n * sizeof *a);
/* 释放 malloc 系分配的内存｜传 该内存指针（可 NULL）｜无返回值 */
free(b);

/* —— 字符串转数值 —— */
/* 串转 int（不推荐，无法报错）｜传 字符串｜成功返值｜遇非法返 0 */
int i = atoi("42");
/* 串转 double（不推荐，无法报错）｜传 字符串｜成功返值｜遇非法返 0 */
double d = atof("3.14");
char *end;
/* 串转 long｜传 串+endptr+base(0/8/10/16)｜成功返值、endptr 指向停下处｜溢出返 LONG_MAX/MIN 且 errno=ERANGE，无法转换返 0；v=42 */
long v = strtol("2a", &end, 16);
/* 串转 unsigned long（strtol 无符号版）｜传 串+endptr+base｜成功返值｜溢出返 ULONG_MAX 且 errno=ERANGE；u=255 */
unsigned long u = strtoul("ff", &end, 16);
/* 串转 double｜传 串+endptr｜成功返值｜溢出返 ±HUGE_VAL 且 errno=ERANGE，无法转换返 0；x=1500.0 */
double x = strtod("1.5e3", &end);
/* 串转 long long（64 位版，另有 strtoull）｜传 串+endptr+base｜成功返值｜溢出返 LLONG_MAX/MIN 且 errno=ERANGE */
long long ll = strtoll("9000000000", &end, 10);

/* —— 随机数 —— */
/* 设随机序列起点（只播一次）｜传 种子｜无返回值 */
srand(time(NULL));
/* 取伪随机数｜无参｜返回 [0, RAND_MAX] 的 int（无失败） */
int r = rand() % 100;

/* —— 排序与查找 —— */
/* 通用快排、原地排序（cmp 见 03 章）｜传 首地址+元素个数+元素大小+比较函数｜无返回值 */
qsort(a, n, sizeof *a, cmp);
int key = 7;
/* 有序数组二分查找｜传 键地址+数组+个数+元素大小+比较函数｜命中返元素指针｜未命中返 NULL */
int *hit = bsearch(&key, a, n, sizeof *a, cmp);

/* —— 进程控制 —— */
/* 注册退出回调（后注册先执行）｜传 回调函数｜成功返 0｜失败返非 0 */
atexit(cleanup);
/* 正常终止进程（刷新并关闭所有流）｜传 退出码｜不返回 */
exit(EXIT_SUCCESS);
/* 异常终止（触发 SIGABRT、不做清理）｜无参｜不返回 */
abort();

/* —— 环境与整数 —— */
/* 取环境变量值｜传 变量名｜存在返值字符串｜不存在返 NULL */
char *path = getenv("PATH");
/* 交 shell 执行命令｜传 命令串｜成功返命令退出状态｜无法启动 shell 返 -1 */
system("ls -l");
/* 取绝对值｜传 int｜返回其绝对值（无失败）；m=5 */
int m = abs(-5);
/* 取绝对值（long 版）｜传 long｜返回其绝对值（无失败）；ml=5 */
long ml = labs(-5L);
/* 同时求商与余｜传 被除数+除数｜返回 div_t{.quot 商,.rem 余}（无失败）；.quot=3、.rem=2 */
div_t qr = div(17, 5);

char buf[32];

/* —— 长度与复制 —— */
/* 拷贝字符串（含 '\0'，dst 须够大）｜传 dst+src｜返回 dst（无失败） */
strcpy(buf, "hello");
/* 求串长｜传 字符串｜返回长度（不含 '\0'，无失败）；此处 5 */
size_t n = strlen(buf);
/* 定长拷贝（源超长不补 '\0'，详见 02 章）｜传 dst+src+n｜返回 dst（无失败） */
strncpy(buf, "hi", 3);
/* 拼接到 dst 末尾｜传 dst+src｜返回 dst（无失败） */
strcat(buf, ", world");
/* 定长拼接（最多追加 n 字节并补 '\0'）｜传 dst+src+n｜返回 dst（无失败） */
strncat(buf, "!!!", 2);
/* malloc 一份副本并拷入（POSIX/C23，用完 free）｜传 字符串｜成功返新指针｜失败返 NULL */
char *dup = strdup("hi");

/* —— 比较 —— */
/* 按字典序比较整串｜传 两串｜返回 负/0/正（相等为 0，无失败） */
if (strcmp(buf, "hello, world") == 0) { }
/* 只比前 n 字节｜传 两串+n｜返回 负/0/正（无失败）；此处 0 */
strncmp("hello", "help", 3);

/* —— 查找与切分 —— */
/* 找字符首次出现｜传 串+字符｜命中返该处指针｜未命中返 NULL */
char *c = strchr(buf, ',');
/* 找字符最后一次出现｜传 串+字符｜命中返指针｜未命中返 NULL */
char *e = strrchr(buf, 'l');
/* 找子串首次出现｜传 串+子串｜命中返指针｜未命中返 NULL */
char *w = strstr(buf, "world");
/* 找「集合内任一字符」首次出现｜传 串+字符集合｜命中返指针｜未命中返 NULL */
char *p = strpbrk(buf, ",;");
/* 数开头连续「属于集合」的字符｜传 串+集合｜返回该长度（无失败） */
size_t pre = strspn(buf, "0123456789");
/* 数开头连续「不属于集合」的字符（即到首个分隔符的长度）｜传 串+集合｜返回该长度（无失败） */
size_t cut = strcspn(buf, ",;");
/* 按分隔符切分（改写原串、不可重入）｜传 串+分隔符集合（续切传 NULL）｜命中返下一段指针｜无更多返 NULL */
char *tok = strtok(s, ",;");

/* —— 内存块操作 —— */
/* 拷 n 字节（区间不可重叠）｜传 dst+src+n｜返回 dst（无失败） */
memcpy(dst, src, 16);
/* 允许重叠的安全拷贝｜传 dst+src+n｜返回 dst（无失败） */
memmove(buf + 1, buf, 5);
/* 把 n 字节全置为 c（常用于清零）｜传 dst+字节值c+n｜返回 dst（无失败） */
memset(buf, 0, sizeof buf);
/* 按字节比较 n 字节｜传 两块+n｜返回 负/0/正（无失败） */
memcmp(dst, src, 16);
/* 在前 n 字节找字节 c｜传 块+字节c+n｜命中返指针｜未命中返 NULL */
void *hit = memchr(buf, 'w', n);

unsigned char c = 'A';

/* —— 分类判断（下列 8 个同构，作用见各行）—— */
/* 共同约定｜传 一个 unsigned char 值或 EOF｜命中该类返非 0｜否则返 0（无其它失败） */
isalpha(c);          /* 是否字母；'A' → 非 0 */
isdigit('7');        /* 是否十进制数字；'7' → 非 0 */
isalnum(c);          /* 是否字母或数字 */
isspace(' ');        /* 是否空白（空格/Tab/换行等）；' ' → 非 0 */
isupper(c);          /* 是否大写字母 */
islower(c);          /* 是否小写字母 */
ispunct('!');        /* 是否可打印的标点符号 */
isxdigit('F');       /* 是否十六进制数字 0-9a-fA-F */

/* —— 大小写转换 —— */
/* 转小写｜传 字符｜返回其小写，非大写字母原样返回（无失败）；'A' → 'a' */
int lo = tolower(c);
/* 转大写｜传 字符｜返回其大写，非小写字母原样返回（无失败）；'a' → 'A' */
int up = toupper(lo);

#include <math.h>

/* —— 幂与对数（作用见各行）—— */
/* 组约定｜传 double（幂类传两个）｜成功返 double｜定义域错返 NaN+errno=EDOM、溢出返 ±HUGE_VAL+errno=ERANGE */
sqrt(2.0);            /* 平方根（x 须 ≥0，否则 NaN）；≈ 1.414 */
cbrt(27.0);           /* 立方根（负数合法）；3.0 */
pow(2.0, 10);         /* base 的 exp 次方（传 底,指数）；1024.0 */
exp(1.0);             /* 自然指数 e 的 x 次方；≈ 2.718 */
log(exp(1.0));       /* 自然对数 ln x（x>0；x=0 返 -inf、x<0 返 NaN）；1.0 */
log10(1000.0);        /* 常用对数 lg x（同上定义域）；3.0 */

/* —— 三角（作用见各行）—— */
/* 组约定｜正/余/正切传弧度、反三角传比值｜成功返 double｜比值越界域错返 NaN */
sin(0.0);             /* 正弦；0.0 */
cos(0.0);             /* 余弦；1.0 */
tan(0.0);             /* 正切；0.0 */
asin(1.0);            /* 反正弦，返回弧度（比值须 [-1,1]，越界 NaN）；≈1.571 */
acos(1.0);            /* 反余弦，返回弧度（比值须 [-1,1]，越界 NaN）；0.0 */
atan(1.0);            /* 反正切，返回弧度；≈0.785 */
atan2(1.0, 1.0);      /* 由 (y,x) 求弧度角、区分象限（比 atan 实用）；≈0.785 */

/* —— 取整（作用见各行）—— */
/* 组约定｜传 double｜成功返取整后的 double｜无失败 */
floor(2.7);           /* 向下取整；2.0 */
ceil(2.1);            /* 向上取整；3.0 */
round(2.5);           /* 四舍五入到最近整数；3.0 */
trunc(-2.7);          /* 向零截断；-2.0 */

/* —— 其它（各行标注入参与返回，均无 errno 失败）—— */
fabs(-3.5);           /* 浮点绝对值｜传 x｜返回 |x|；3.5 */
fmod(7.5, 2.0);       /* 浮点取余｜传 x,y｜返回 x 除以 y 的余数；1.5 */
fmax(1.0, 2.0);       /* 取较大｜传两值｜返回较大者；2.0 */
fmin(1.0, 2.0);       /* 取较小｜传两值｜返回较小者；1.0 */
hypot(3.0, 4.0);      /* 斜边长｜传 x,y｜返回 √(x²+y²) 且防中间溢出；5.0 */
log2(8.0);            /* 以 2 为底对数｜传 x｜返回 log₂x；3.0 */

/* —— 判定特殊值（宏；传 double，返回真假 非 0/0，无失败）—— */
isnan(x);              /* 是否 NaN——NaN 连自己都不相等，只能这样判 */
isinf(x);              /* 是否 ±无穷（如 1.0/0.0） */
/* 编译：gcc prog.c -lm */

#include <time.h>

/* —— 取时间与计时 —— */
/* 取当前日历时间｜传 time_t 指针（可 NULL）｜成功返自 Epoch(1970-01-01 UTC)起的秒数｜失败返 (time_t)-1 */
time_t now = time(NULL);
/* 取程序 CPU 用时｜无参｜成功返 CPU 时钟数（÷CLOCKS_PER_SEC 得秒）｜不可用返 (clock_t)-1 */
clock_t t0 = clock();
/* 求两时刻秒差｜传 两个 time_t｜返回相差的秒数 double（无失败） */
double dt = difftime(now, start);

/* —— 分解与合成 —— */
/* 转本地时区分解时间｜传 time_t 指针｜成功返 struct tm*（指向内部静态缓冲）｜失败返 NULL */
struct tm *lt = localtime(&now);
/* 转 UTC 分解时间｜传 time_t 指针｜成功返 struct tm*（同为静态缓冲）｜失败返 NULL */
struct tm *ut = gmtime(&now);
/* 分解时间合成回时间戳｜传 struct tm*（按本地时区）｜成功返 time_t｜失败返 (time_t)-1 */
time_t back = mktime(lt);

/* —— 格式化 —— */
char ts[64];
/* 按格式输出时间串（%Y %m %d %H %M %S 等）｜传 缓冲+容量+格式+tm*｜成功返写出字符数｜装不下返 0 */
strftime(ts, sizeof ts, "%Y-%m-%d %H:%M:%S", lt);

/* —— struct tm 常用字段 —— */
int year = lt->tm_year + 1900;   /* tm_year：自 1900 起的年数 */
int mon  = lt->tm_mon + 1;       /* tm_mon：0-11，+1 才是日常月份 */
int day  = lt->tm_mday;             /* tm_mday：1-31 */
int secs = lt->tm_hour*3600 + lt->tm_min*60 + lt->tm_sec; /* tm_hour / tm_min / tm_sec 时分秒 */
int wday = lt->tm_wday;             /* tm_wday：0=周日 */
int yday = lt->tm_yday;             /* tm_yday：0-365，当年第几天 */

#include <stdbool.h>
#include <stdarg.h>
#include <stddef.h>

/* —— 布尔 <stdbool.h>（C99） —— */
bool ok = true;                    /* bool/true/false，本质是 _Bool；任何非 0 存进去都变 1 */
if (!ok) return false;

/* —— 变参函数 <stdarg.h>（下列 3 个都是宏、均无返回值）—— */
void log_line(const char *fmt, ...) { /* ... 表示后面还有不定个实参 */
    va_list ap;
    /* 启动变参读取｜传 va_list+最后一个具名形参｜使 ap 指向首个变参 */
    va_start(ap, fmt);
    /* 转发整包变参给 v* 版函数（见 stdio 卡）｜传 流+格式+va_list｜成功返写出字符数、出错返负数 */
    vfprintf(stderr, fmt, ap);
    /* 收尾，必须与 va_start 配对｜传 va_list */
    va_end(ap);
}
/* 逐个取用｜int x = va_arg(ap, int)：传 va_list+类型｜返回该类型的下一个实参｜类型数错即 UB */

/* —— 通用定义 <stddef.h>（下面前 3 个是类型/常量，非函数）—— */
size_t n = sizeof buf;             /* size_t：表示大小/下标的无符号类型（sizeof 的结果类型） */
void *p = NULL;                      /* NULL：空指针常量 */
ptrdiff_t d = &a[3] - &a[0];   /* ptrdiff_t：两指针相减的有符号结果类型；d=3 */
/* 求字段偏移（宏）｜传 结构体类型+字段名｜返回该字段在结构体内的字节偏移（无失败） */
size_t off = offsetof(struct S, field);

#include <assert.h>
#include <errno.h>
#include <limits.h>
#include <stdint.h>
#include <float.h>

/* —— 断言 <assert.h> —— */
/* 运行期断言（宏，详见 04 章）｜传 一个表达式｜为真无操作｜为假打印信息并 abort；NDEBUG 时整条被编译掉 */
assert(ptr != NULL);

/* —— 错误处理 <errno.h> —— */
errno = 0;                         /* errno 是左值，可赋值；用前必须先清零 */
long v = strtol(s, NULL, 10);
if (errno == ERANGE)               /* 溢出 */
    /* 错误码转可读串｜传 错误码｜返回其字符串（指向静态缓冲、勿改，无失败） */
    fprintf(stderr, "%s\n", strerror(errno));
/* 按 errno 打印「前缀: 描述」到 stderr（详见 04 章调试卡）｜传 前缀串｜无返回值 */
perror("open");

/* —— 整数边界 <limits.h> —— */
int hi = INT_MAX, lo = INT_MIN;     /* int 上限 / 下限 */
unsigned um = UINT_MAX;             /* unsigned 上限 */
long lm = LONG_MAX;                 /* long 上限 */
size_t sm = SIZE_MAX;               /* size_t 上限（来自 <stdint.h>） */
int bits = CHAR_BIT;                /* 一个字节的位数（通常为 8） */

/* —— 固定宽度 <stdint.h> —— */
int32_t  a = INT32_MAX;              /* 精确 32 位，对应边界宏 INT32_MAX（详见 02 章） */
uint32_t b = 0u;                    /* 精确无符号 32 位 */
int64_t  c = 0;                     /* 精确 64 位 */
uint64_t d = UINT64_MAX;             /* 精确无符号 64 位，对应边界宏 UINT64_MAX */

/* —— 可移植打印定宽类型 <inttypes.h> —— */
printf("%" PRId64 "\n", c);       /* PRIdN/PRIuN/PRIxN 展开成本平台的长度修饰，省得在 %d/%ld 间猜 */

/* —— 浮点特性 <float.h> —— */
if (fabs(x - y) < DBL_EPSILON) { }   /* 1.0 与下一个可表示 double 的最小差，用作比较阈值 */
float  fe = FLT_EPSILON;             /* float 版精度阈值 */
double dm = DBL_MAX;                /* double 可表示的最大值 */

#include <signal.h>

/* 处理函数里只能碰 volatile sig_atomic_t 与异步信号安全函数 */
volatile sig_atomic_t got = 0;

/* 信号处理函数：签名固定为 void f(int) */
void on_int(int sig) { got = sig; }   /* 只置标志，重活留给主循环 */

/* 注册处理函数｜传 信号编号+处理函数（或 SIG_IGN 忽略/SIG_DFL 默认）｜成功返之前的处理函数｜失败返 SIG_ERR */
if (signal(SIGINT, on_int) == SIG_ERR) return 1;

/* 主动发信号给自己｜传 信号编号｜成功返 0｜失败返非 0 */
raise(SIGTERM);

while (!got) { }                /* 等 Ctrl-C：收到后 got 被置为 SIGINT */
/* 标准信号：SIGINT(中断) SIGTERM(终止) SIGABRT(abort) SIGSEGV(段错误) SIGFPE(算术错) SIGILL(非法指令) */

#include <setjmp.h>

jmp_buf env;                     /* 存档缓冲，通常放全局 */

void deep(int n) {
    if (n == 0)
        longjmp(env, 42);        /* 跳回 setjmp 处，第二参作为其返回值（不能为 0） */
    deep(n - 1);
}

/* 设置存档点｜传 jmp_buf｜直接调用时返 0｜被 longjmp 跳回时返 longjmp 的第二参 */
int r = setjmp(env);
if (r == 0)
    deep(5);                    /* 首次：r==0，往下钻 */
else
    printf("跳回，值=%d\n", r);     /* longjmp 之后：r==42 */

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

/* 设置区域｜传 类别(LC_ALL 等)+区域名（""取环境变量、NULL 只查询）｜成功返当前区域串｜失败返 NULL */
setlocale(LC_ALL, "");           /* 按环境（如 zh_CN.UTF-8）启用本地化 */

/* —— 宽字符 I/O 与字符串（与窄版一一对应）—— */
wchar_t wbuf[64];
wprintf(L"宽字符：%ls\n", L"你好");   /* printf 宽版，字面量加 L 前缀 */
size_t wl = wcslen(L"héllo");         /* strlen 宽版：按 wchar_t 个数计 */
wcscpy(wbuf, L"复制");                /* strcpy 宽版 */
int cmp = wcscmp(L"a", L"b");        /* strcmp 宽版 */

/* —— 宽字符分类 <wctype.h>（ctype 的宽版，认本地字母）—— */
iswalpha(L'中');              /* 是否字母（本地规则下汉字算字母）→ 非 0 */
iswdigit(L'7');              /* 是否数字 */
towupper(L'a');              /* 转大写宽字符 */

/* —— 多字节 ⇄ 宽字符转换（按当前区域编码，如 UTF-8）—— */
/* 多字节串转宽串｜传 目标wchar数组+源多字节串+目标容量｜成功返写入的wchar数｜遇非法字节返 (size_t)-1 */
size_t n = mbstowcs(wbuf, "你好", 64);

/* —— <complex.h> 复数（C99）—— */
#include <complex.h>
double complex z = 3.0 + 4.0*I;  /* complex 类型 + 虚数单位 I */
double m = cabs(z);              /* 模 |z|=5；creal/cimag 取实/虚部，cexp/csqrt 等复数版数学函数 */

/* —— <fenv.h> 浮点环境（C99；配合 #pragma STDC FENV_ACCESS ON）—— */
#include <fenv.h>
feclearexcept(FE_ALL_EXCEPT);    /* 清浮点异常标志 */
double r = 1.0 / 3.0;
if (fetestexcept(FE_INEXACT)) { }  /* 查是否发生 FE_OVERFLOW/FE_DIVBYZERO/FE_INVALID/FE_INEXACT */
fesetround(FE_TONEAREST);        /* 设舍入方向 */

/* —— 其余标准头，一句话点名（用到再查手册）—— */
/* <tgmath.h>      泛型数学：sqrt(x) 按 x 类型自动选 sqrtf/sqrt/sqrtl */
/* <uchar.h>       C11：char16_t / char32_t 与 UTF-16/32 转换 */
/* <stdalign.h>    C11：alignas / alignof 控制对齐（C23 起成关键字，可免包含） */
/* <stdnoreturn.h> C11：noreturn 标注不返回的函数——C23 改用 [[noreturn]] */
/* <iso646.h>      and/or/not 等运算符的可读别名（老式键盘遗产） */
/* <stdatomic.h> 原子类型、<threads.h> C11 线程——见 04 章并发卡 */

进程 A 的 fd 表        打开文件表(全系统一份)        inode 表
  0 ──┐                ┌─> [偏移=6, O_RDONLY] ──┐
  1   │                │                        ├─> data.txt 的 inode
  3 ──┼────────────────┘                        │   (文件本体、大小、权限)
  5 ──┘  dup 出来的                             │
  4 ───────────────────> [偏移=0, O_RDONLY] ────┘  另一次 open，另一条表项

[1] 第一次 open fd=3, 第二次 fd=4
[1] close(3) 之后再 open, 又拿到 fd=3     <- 复用最小空号
[2] fd3 读到 "ABC" 之后, fd4 的偏移仍是 0  <- 两次 open，互不相干
[3] dup(3)=5 ; 读之前 fd3 偏移=3, fd5 偏移=3
[3] fd5 读到 "DEF" ; 现在 fd3 偏移=6, fd5 偏移=6   <- 同进同退

#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>

int main(void) {
    int f = open("data.txt", O_WRONLY | O_CREAT | O_TRUNC, 0644);
    write(f, "ABCDEFGHIJ", 10);
    close(f);

    /* [1] 编号：总是给最小的可用号，close 后立刻复用 */
    int a = open("data.txt", O_RDONLY);   /* 3（0/1/2 已被占） */
    int b = open("data.txt", O_RDONLY);   /* 4 */
    close(a);
    int c = open("data.txt", O_RDONLY);   /* 又是 3 */

    /* [2] 两次 open = 两条打开文件表项 = 两个独立偏移 */
    char buf[4] = {0};
    read(c, buf, 3);                     /* c 读走 "ABC"，c 的偏移 -> 3 */
    lseek(b, 0, SEEK_CUR);                 /* b 的偏移仍是 0，纹丝不动 */

    /* [3] dup = 两个 fd 指向同一条表项 = 偏移共享 */
    int d = dup(c);                       /* 复制到当前最小空号 */
    read(d, buf, 3);                     /* d 读走 "DEF"，不是 "ABC" */
    printf("c=%ld d=%ld\n",              /* 6 和 6：动 d，c 跟着走 */
           (long)lseek(c, 0, SEEK_CUR),
           (long)lseek(d, 0, SEEK_CUR));

    /* [4] 同一个编号空间里，什么种类的 fd 都能并排躺着 */
    int pfd[2];
    pipe(pfd);                            /* 一次给一对，接着往下发号 */
    write(pfd[1], "hi", 2);               /* 管道上用 write，不必用 send */
    read(pfd[0], buf, 2);

    return 0;
}

ls -l /proc/self/fd/
0 -> /dev/pts/0            # 终端
3 -> /home/me/data.txt     # 普通文件
7 -> socket:[123456]       # 套接字，方括号里是 inode 号
8 -> pipe:[20432]          # 管道

#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <stdlib.h>
#include <fcntl.h>

/* 规则①：判据是返回值，errno 只用来问「为什么」 */
int fd = open(path, O_RDONLY);
if (fd < 0) {                     /* 先看返回值 */
    int saved = errno;             /* 规则②：立刻存下来 */
    fprintf(stderr, "open %s failed: %s\n", path, strerror(saved));
    if (saved == ENOENT) { /* 文件不在，也许该创建 */ }
    if (saved == EACCES) { /* 没权限，换条路 */ }
    return -1;
}

/* 规则②的反例：中间夹了库调用，errno 就不保险了 */
if (fd < 0) {
    fprintf(stderr, "出错了\n");      /* 这一行有权改掉 errno */
    if (errno == ENOENT) { }        /* 读到的可能已经不是刚才那个了 */
}

/* 规则③：strtol 无法用返回值报错，必须先清零 */
errno = 0;
char *end;
long v = strtol(s, &end, 10);
if (end == s)            { /* 一个数字都没解析出来 */ }
else if (errno == ERANGE) { /* 溢出，v 是 LONG_MAX/LONG_MIN */ }
else if (*end != '\0')   { /* 后面还有尾巴，比如 "12abc" */ }

/* EINTR：重试，不是错误 */
ssize_t n;
do { n = read(fd, buf, sizeof buf); } while (n < 0 && errno == EINTR);

strace -e trace=openat ./app
openat(AT_FDCWD, "/nonexistent", O_RDONLY) = -1 ENOENT (No such file or directory)

#include <fcntl.h>
#include <unistd.h>

/* 打开文件｜传 路径+标志(O_RDONLY/O_WRONLY/O_RDWR 组合 O_CREAT/O_APPEND/O_TRUNC)+权限(仅 O_CREAT 用)｜成功返 fd(≥0)｜失败返 -1 置 errno */
int fd = open("data.txt", O_RDONLY);
if (fd < 0) { perror("open"); return 1; }

char buf[4096];
/* 读字节｜传 fd+缓冲+最多读 n｜成功返实际读入字节数(0=EOF)｜失败返 -1 置 errno */
ssize_t got = read(fd, buf, sizeof buf);

int out = open("copy.txt", O_WRONLY | O_CREAT | O_TRUNC, 0644);
/* 写字节｜传 fd+缓冲+写 n｜成功返实际写出字节数(可能 <n，须循环补写)｜失败返 -1 置 errno */
ssize_t put = write(out, buf, got);

/* 移动读写位置｜传 fd+偏移+基准(SEEK_SET/CUR/END)｜成功返新的绝对偏移｜失败返 -1 */
off_t pos = lseek(fd, 0, SEEK_END);   /* 跳到末尾＝取文件大小 */

/* 关闭 fd｜传 fd｜成功返 0｜失败返 -1 */
close(fd); close(out);

/* 复制 fd 到指定号(先关目标)｜传 旧fd+新fd｜成功返新fd｜失败返 -1 */
dup2(out, STDOUT_FILENO);          /* 重定向 stdout 到文件——shell 的 > 就靠它 */

#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>

struct stat st;
/* 取文件元数据｜传 路径+struct stat*｜成功返 0 并填充 st｜失败返 -1 置 errno */
if (stat("data.txt", &st) == 0) {
    off_t  size = st.st_size;        /* 字节大小 */
    mode_t mode = st.st_mode;        /* 类型+权限位 */
    time_t mt   = st.st_mtime;       /* 最后修改时间（配 localtime 用）*/

    /* 类型判断用宏，别手算 */
    if (S_ISREG(mode)) { }             /* 普通文件 */
    if (S_ISDIR(mode)) { }             /* 目录 */
    if (S_ISLNK(mode)) { }             /* 符号链接（需 lstat 才不跟随）*/
}
/* fstat：对已打开的 fd 取元数据｜传 fd+struct stat*｜成功返 0｜失败返 -1 */
fstat(fd, &st);

/* 建目录｜传 路径+权限｜成功返 0｜失败返 -1（已存在则 errno==EEXIST）*/
mkdir("out", 0755);
/* 改权限｜传 路径+权限｜成功返 0｜失败返 -1 */
chmod("run.sh", 0755);

/* 探测可访问性｜传 路径+模式(F_OK 存在/R_OK 读/W_OK 写/X_OK 执行)｜可访问返 0｜否则返 -1 置 errno */
if (access("cfg", F_OK) == 0) { }   /* 文件存在 */

#include <dirent.h>

/* 打开目录｜传 路径｜成功返 DIR*｜失败返 NULL 置 errno */
DIR *d = opendir(".");
if (!d) { perror("opendir"); return 1; }

struct dirent *e;
/* 读下一条｜传 DIR*｜成功返 struct dirent*（内部静态，勿存）｜读完或出错返 NULL */
while ((e = readdir(d)) != NULL) {
    /* 跳过 . 与 .. 两个特殊项 */
    if (e->d_name[0] == '.' &&
        (e->d_name[1] == '\0' || (e->d_name[1] == '.' && e->d_name[2] == '\0')))
        continue;
    printf("%s\n", e->d_name);       /* d_name：条目名（不含路径）*/
}
/* 关闭目录流｜传 DIR*｜成功返 0｜失败返 -1 */
closedir(d);

#include <unistd.h>

/* 创建子进程(复制自身)｜无参｜父进程里返子 PID(>0)、子进程里返 0｜失败返 -1 置 errno */
pid_t pid = fork();

/* 用新程序替换当前进程映像｜传 命令+参数列表(NULL 结尾)｜成功不返回｜失败才返 -1 */
execvp("ls", (char*[]){ "ls", "-l", NULL });  /* execlp/execv/execve 一族，传参形式不同 */

pid_t me     = getpid();     /* 本进程 PID（无失败）*/
pid_t parent = getppid();    /* 父进程 PID（无失败）*/

/* 无缓冲结束进程(fork 后子进程 exec 失败时该用它，绕开 atexit 与 stdio 刷缓冲)｜传 退出码｜不返回 */
_exit(127);

int fd[2];
/* 建管道｜传 int[2]｜成功返 0 并填 fd[0]读端/fd[1]写端｜失败返 -1 */
pipe(fd);

chdir("/tmp");              /* 改工作目录｜传 路径｜成功返 0｜失败返 -1 */
char cwd[4096];
getcwd(cwd, sizeof cwd);   /* 取工作目录｜传 缓冲+容量｜成功返 buf｜装不下返 NULL 置 errno */

unsigned left = sleep(3);   /* 睡 n 秒｜传 秒数｜睡满返 0｜被信号提前唤醒返剩余秒数 */

#include <sys/wait.h>

int status;
/* 等任一子进程结束｜传 int* 收状态｜成功返结束的子 PID｜无子进程/失败返 -1 */
pid_t done = wait(&status);

/* 等指定子进程｜传 PID(-1=任意)+int*+标志(0 阻塞、WNOHANG 非阻塞立即返)｜成功返子 PID(WNOHANG 且无就绪返 0)｜失败返 -1 */
waitpid(pid, &status, 0);

/* —— 用宏解读 status —— */
if (WIFEXITED(status))          /* 是否正常 return/exit 结束 */
    printf("退出码 %d\n", WEXITSTATUS(status));  /* 取 0-255 退出码 */
if (WIFSIGNALED(status))        /* 是否被信号杀死 */
    printf("被信号 %d 杀死\n", WTERMSIG(status));  /* 取致命信号编号 */

#include <signal.h>

volatile sig_atomic_t stop = 0;
void on_term(int sig) { stop = 1; }

/* 注册信号处理(比 signal 更可靠)｜传 信号+新 sigaction*(可NULL)+旧 sigaction*(可NULL)｜成功返 0｜失败返 -1 */
struct sigaction sa = {0};
sa.sa_handler = on_term;
sigemptyset(&sa.sa_mask);          /* 处理期间额外屏蔽的信号集，先清空 */
sa.sa_flags = SA_RESTART;          /* 让被打断的慢系统调用自动重启 */
sigaction(SIGTERM, &sa, NULL);

/* 给进程发信号｜传 目标PID(>0 该进程/0 本进程组/-1 广播)+信号(0=只探测存活)｜成功返 0｜失败返 -1 */
kill(pid, SIGTERM);

/* —— 信号集与屏蔽 —— */
sigset_t set;
sigemptyset(&set);                /* 清空信号集｜成功返 0 */
sigaddset(&set, SIGINT);           /* 往集合加一个信号｜成功返 0 */
/* 改本线程的信号屏蔽字｜传 how(SIG_BLOCK/UNBLOCK/SETMASK)+新集*+旧集*(可NULL)｜成功返 0｜失败返 -1 */
sigprocmask(SIG_BLOCK, &set, NULL);  /* 进临界区前挡住 SIGINT */

#include <pthread.h>

void *worker(void *arg) { return NULL; }   /* 线程函数签名固定：void* f(void*) */

pthread_t t;
/* 创建线程｜传 pthread_t*+属性(NULL 默认)+线程函数+传给它的参数｜成功返 0｜失败返错误码(不置 errno!) */
pthread_create(&t, NULL, worker, NULL);
/* 等线程结束并取返回值｜传 pthread_t+void** 收返回值(可NULL)｜成功返 0｜失败返错误码 */
pthread_join(t, NULL);
/* 或分离：不再 join，结束即自动回收——pthread_detach(t) */

/* —— 互斥锁 —— */
pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_lock(&mtx);          /* 进临界区(阻塞直到拿到)｜成功返 0 */
/* ... 改共享数据 ... */
pthread_mutex_unlock(&mtx);        /* 出临界区｜成功返 0 */

/* —— 条件变量：等某个条件成立 —— */
pthread_cond_t cv = PTHREAD_COND_INITIALIZER;
pthread_mutex_lock(&mtx);
while (!ready)                      /* while 而非 if：防虚假唤醒 */
    pthread_cond_wait(&cv, &mtx);    /* 原子地「放锁+睡」，被唤醒后重新持锁 */
pthread_mutex_unlock(&mtx);
/* 另一线程：改好条件后 pthread_cond_signal(&cv) 唤醒 */

#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

/* 建套接字｜传 域(AF_INET IPv4)+类型(SOCK_STREAM TCP/SOCK_DGRAM UDP)+协议(0 自动)｜成功返 fd｜失败返 -1 */
int s = socket(AF_INET, SOCK_STREAM, 0);

struct sockaddr_in addr = {0};
addr.sin_family = AF_INET;
addr.sin_port = htons(8080);       /* 端口转网络字节序(大端)；htonl 转 32 位 */
addr.sin_addr.s_addr = INADDR_ANY; /* 监听所有网卡；或 inet_pton(AF_INET,"1.2.3.4",&addr.sin_addr) */

/* —— 服务端 —— */
int yes = 1;
setsockopt(s, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof yes);  /* 允许重启快速复用端口 */
bind(s, (struct sockaddr*)&addr, sizeof addr);  /* 绑地址｜成功返 0｜失败返 -1 */
listen(s, 128);                  /* 转为监听、设 backlog｜成功返 0｜失败返 -1 */
/* 取一个已完成连接｜传 监听fd+对端地址*(可NULL)+长度*｜成功返新的连接 fd｜失败返 -1 */
int conn = accept(s, NULL, NULL);

char buf[1024];
/* 收数据｜传 fd+缓冲+长度+标志(0)｜成功返收到字节数(0=对端关闭)｜失败返 -1 */
ssize_t n = recv(conn, buf, sizeof buf, 0);
/* 发数据｜传 fd+缓冲+长度+标志(0)｜成功返发出字节数(可能 <请求)｜失败返 -1 */
send(conn, buf, n, 0);

/* —— 客户端：connect(s, (struct sockaddr*)&addr, sizeof addr) 成功返 0、失败返 -1 —— */

#include <sys/mman.h>
#include <fcntl.h>
#include <unistd.h>

int fd = open("big.bin", O_RDONLY);
struct stat st; fstat(fd, &st);

/* 建映射｜传 建议地址(NULL 由内核选)+长度+保护(PROT_READ/WRITE)+标志(MAP_SHARED/PRIVATE)+fd+文件偏移｜成功返映射首地址｜失败返 MAP_FAILED((void*)-1) */
char *p = mmap(NULL, st.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
if (p == MAP_FAILED) { perror("mmap"); return 1; }
close(fd);                          /* 映射建立后 fd 就能关了 */

char first = p[0];                  /* 直接当内存访问，内核按缺页惰性载入 */

/* 匿名映射：不关联文件，等价于向内核直接要一大块内存 */
char *heap = mmap(NULL, 1<<20, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);

/* 改一段映射的保护属性｜传 地址+长度+新保护｜成功返 0｜失败返 -1 */
mprotect(heap, 4096, PROT_READ);   /* 把首页设为只读——再写就 SIGSEGV */

/* 解除映射｜传 首地址+长度｜成功返 0｜失败返 -1 */
munmap(p, st.st_size);
munmap(heap, 1<<20);

#define _GNU_SOURCE            /* 必须在所有 #include 之前 */
#include <stdio.h>
#include <string.h>

/* —— 安全读整行（推荐替代 fgets，自动扩容）—— */
char *line = NULL; size_t cap = 0;
/* 读一行(含换行)｜传 char**行缓冲(自动 malloc/realloc)+size_t*容量+流｜成功返读入字节数｜EOF/失败返 -1 */
ssize_t len = getline(&line, &cap, stdin);
free(line);                    /* 由 getline 分配，用完自己 free */

/* —— 格式化到新分配的缓冲（省去先算长度）—— */
char *msg;
/* 分配并格式化｜传 char**(接收 malloc 出的串)+格式+实参｜成功返写入长度｜失败返 -1 */
int n = asprintf(&msg, "user-%d", 42);
free(msg);

/* —— 其它常用扩展 —— */
char *dup = strdup("copy me");   /* 复制字符串到新 malloc 的缓冲(C23 起已入标准)；用完 free */
char *d2  = strndup("hello", 3); /* 最多复制 n 字节版 */
void *hit = memmem(hay, hn, "needle", 6);  /* 在内存块里找子块(strstr 的二进制版) */