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

void cleanup(void) {
    printf("👋 程序要退出了，我在做最后的清理工作！\n");
}

void cleanup2(void) {
    printf("📝 正在保存日志...\n");
}

int main(void) {
    // 注册退出处理函数
    atexit(cleanup);   // 先注册，先被调用...不对！
    atexit(cleanup2);  // 后注册，后调用...不对不对！

    // 实际上执行顺序是反的：后注册的先执行
    printf("程序正在运行...\n");

    return 0;
    // 程序退出时会自动调用 cleanup2，然后 cleanup
}

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

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

void quick_cleanup(void) {
    printf("⚡ 快速清理中，不刷新缓冲区！\n");
}

int main(void) {
    at_quick_exit(quick_cleanup);

    printf("准备快速退出...\n");
    quick_exit(0);  // 这会调用 quick_cleanup，但不会刷新 stdout 缓冲区

    // 这行不会执行
    printf("这行永远不会出现！\n");

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

void cleanup(void) {
    printf("✅ 清理完成，缓冲区已刷新！\n");
}

int main(void) {
    atexit(cleanup);

    printf("正在写入重要数据...");  // 注意：没有 \n

    // 模拟某个致命错误
    printf("哎呀，遇到严重问题！\n");

    exit(1);  // 退出，状态码 1 表示异常退出
    // printf("这里不会执行！\n");

    return 0;
}

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

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

void cleanup(void) {
    // 这个函数永远不会有机会执行
    printf("清理？我连出场的机会都没有！\n");
}

int main(void) {
    atexit(cleanup);

    printf("数据还没保存好...");
    _Exit(0);  // 直接消失！连缓冲区的数据都丢了

    return 0;
}

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

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

void cleanup(void) {
    printf("这个函数不会被调用！\n");
}

int main(void) {
    atexit(cleanup);

    printf("程序遇到了无法恢复的错误！\n");

    abort();  // 自杀！发送 SIGABRT 信号

    printf("永远不会执行到这里\n");

    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>

void fast_cleanup(void) {
    printf("⚡ 快速清理完成！\n");
}

int main(void) {
    at_quick_exit(fast_cleanup);

    printf("程序运行中...\n");

    // 在某些紧急情况下
    if (1) {  // 假设这是某个紧急条件
        quick_exit(0);  // 快速撤退！
    }

    return 0;
}

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

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

int main(void) {
    printf("我要在 C 程序里执行一个 shell 命令！\n\n");

    // 调用系统的 ls 命令（Linux/Mac）或 dir 命令（Windows）
    system("ls -la");  // Linux/Mac
    // system("dir");  // Windows

    printf("\n命令执行完毕，回到 C 程序了！\n");

    return 0;
}

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

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

int main(void) {
    char command[] = "ls -la";
    size_t size = sizeof(command);

    // system_chk 在 C11 引入，会检查命令是否超过指定大小
    system_chk(command, size);  // 更安全！

    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) {
    // 读取 PATH 环境变量
    char *path = getenv("PATH");

    if (path != NULL) {
        printf("🔍 PATH 环境变量内容是：\n%s\n", path);
    } else {
        printf("PATH 环境变量不存在！\n");
    }

    // 读取 HOME（在 Windows 上是 USERPROFILE）
    char *home = getenv("HOME");  // Linux/Mac
    if (home == NULL) {
        home = getenv("USERPROFILE");  // Windows 备用
    }

    if (home != NULL) {
        printf("\n🏠 主目录：%s\n", home);
    }

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

int main(void) {
    char buffer[1024];
    size_t buffer_size = sizeof(buffer);

    // getenv_s 是安全版本，会检查缓冲区大小
    errno_t err = getenv_s(&buffer_size, buffer, buffer_size, "PATH");

    if (err == 0) {
        printf("PATH = %s\n", buffer);
    } else {
        printf("读取 PATH 失败或缓冲区太小！\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>
#include <stdlib.h>

int main(void) {
    // 读取原来的值
    char *old_value = getenv("MY_VAR");

    printf("原来的 MY_VAR = %s\n", old_value ? old_value : "(未设置)");

    // 设置新的值
    // setenv 需要三个参数：变量名、新值、是否覆盖（1=覆盖，0=不覆盖）
    if (setenv("MY_VAR", "Hello from setenv!", 1) == 0) {
        printf("✅ 设置成功！\n");
        printf("新的 MY_VAR = %s\n", getenv("MY_VAR"));
    } else {
        perror("setenv 失败");
    }

    // 用 putenv 也可以（但注意：putenv 可能会直接使用传入的字符串）
    putenv("ANOTHER_VAR=Hello from putenv!");
    printf("ANOTHER_VAR = %s\n", getenv("ANOTHER_VAR"));

    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

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

// 比较函数：告诉 bsearch 怎么比较两个元素
int compare_int(const void *a, const void *b) {
    int *pa = (int *)a;
    int *pb = (int *)b;
    return *pa - *pb;  // 返回负数表示 a<b，正数表示 a>b，0表示相等
}

int main(void) {
    // 注意：数组必须是有序的！二分查找的前提是有序数组
    int arr[] = {1, 5, 10, 15, 20, 25, 30, 35, 40, 50};
    int n = sizeof(arr) / sizeof(arr[0]);

    int target = 25;

    // bsearch 的参数：
    // key: 要找的东西
    // base: 数组的起始地址
    // num: 数组元素个数
    // width: 每个元素的大小（字节数）
    // comparison: 比较函数
    int *result = bsearch(&target, arr, n, sizeof(int), compare_int);

    if (result != NULL) {
        printf("🎯 找到了！%d 在数组的第 %ld 个位置（从0开始）\n",
               *result, result - arr);
    } else {
        printf("❌ 没找到 %d\n", target);
    }

    // 再找一个不存在的
    target = 27;
    result = bsearch(&target, arr, n, sizeof(int), compare_int);
    if (result == NULL) {
        printf("❌ %d 不在数组中\n", target);
    }

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

int compare_int_s(const void *a, const void *b, void *ctx) {
    (void)ctx;  // 这个例子不用 context
    return (*(int *)a) - (*(int *)b);
}

int main(void) {
    int arr[] = {1, 5, 10, 15, 20, 25, 30, 35, 40, 50};
    int n = sizeof(arr) / sizeof(arr[0]);
    int target = 15;

    int *result = bsearch_s(&target, arr, n, sizeof(int), compare_int_s, NULL);

    if (result != NULL) {
        printf("找到了：%d\n", *result);
    }

    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

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

// 比较函数
int compare_int(const void *a, const void *b) {
    int *pa = (int *)a;
    int *pb = (int *)b;
    return *pa - *pb;  // 升序排列
}

int main(void) {
    int arr[] = {64, 34, 25, 12, 22, 11, 90, 5, 77, 30};
    int n = sizeof(arr) / sizeof(arr[0]);

    printf("排序前：");
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");

    // qsort 的参数：
    // base: 数组起始地址
    // num: 元素个数
    // width: 每个元素大小（字节）
    // comparison: 比较函数
    qsort(arr, n, sizeof(int), compare_int);

    printf("排序后：");
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    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

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

int compare_str(const void *a, const void *b) {
    // a 和 b 是 char*，要比较字符串要用 strcmp
    char *sa = *(char **)a;  // 注意：传入的是指针数组，所以 a 是 char**
    char *sb = *(char **)b;
    return strcmp(sa, sb);  // strcmp 本身就返回负/正/0
}

int main(void) {
    char *fruits[] = {"banana", "apple", "cherry", "date", "elderberry"};
    int n = sizeof(fruits) / sizeof(fruits[0]);

    printf("排序前：");
    for (int i = 0; i < n; i++) {
        printf("%s ", fruits[i]);
    }
    printf("\n");

    qsort(fruits, n, sizeof(char *), compare_str);

    printf("排序后：");
    for (int i = 0; i < n; i++) {
        printf("%s ", fruits[i]);
    }
    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

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

int compare_s(const void *a, const void *b, void *ctx) {
    (void)ctx;
    return (*(int *)a) - (*(int *)b);
}

int main(void) {
    int arr[] = {3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5};
    int n = sizeof(arr) / sizeof(arr[0]);

    qsort_s(arr, n, sizeof(int), compare_s, NULL);

    printf("排序后：");
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");

    return 0;
}

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

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

int main(void) {
    // 打印随机数（默认种子是 1，每次程序启动都得到相同序列）
    printf("第一个随机数：%d\n", rand());
    printf("第二个随机数：%d\n", rand());
    printf("第三个随机数：%d\n", rand());

    // RAND_MAX 是 rand 能返回的最大值
    printf("\nRAND_MAX = %d\n", RAND_MAX);
    printf("随机数范围：0 ~ %d\n", RAND_MAX);

    return 0;
}

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

#include <stdio.h>
#include <stdlib.h>
#include <time.h>  // time() 函数在这里

int main(void) {
    // 用当前时间作为种子——这样每次运行结果都不一样！
    srand((unsigned int)time(NULL));

    printf("随机数 1：%d\n", rand());
    printf("随机数 2：%d\n", rand());
    printf("随机数 3：%d\n", rand());

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

int main(void) {
    srand((unsigned int)time(NULL));

    // 生成 1~100 的随机整数
    int num1 = (rand() % 100) + 1;
    printf("1~100 的随机数：%d\n", num1);

    // 生成 0~99 的随机整数
    int num2 = rand() % 100;
    printf("0~99 的随机数：%d\n", num2);

    // 更均匀的分布（推荐方法）
    // 生成 [min, max] 范围的随机数
    int min = 10, max = 50;
    int num3 = min + (rand() % (max - min + 1));
    printf("%d~%d 的随机数：%d\n", min, max, num3);

    return 0;
}

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

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

int main(void) {
    char *line = NULL;       // 缓冲区，初始为 NULL
    size_t len = 0;         // 缓冲区大小
    ssize_t nread;          // 实际读取的字符数

    printf("请输入一些文字（按 Ctrl+D/Ctrl+Z 结束输入）：\n");

    // getline 会自动分配/重新分配内存
    while ((nread = getline(&line, &len, stdin)) != -1) {
        printf("读取了 %zd 个字符，内容是：%s", nread, line);
    }

    free(line);  // 重要：记得释放内存！
    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 <stdlib.h>

int main(void) {
    char *line = NULL;
    size_t len = 0;
    ssize_t nread;

    // 假设我们要读取 CSV 格式的数据（用逗号分隔）
    // 每次遇到逗号就返回一次
    printf("输入 CSV 格式数据（用逗号分隔）：\n");

    // 这里用 '\n' 作为分隔符，所以和 getline 效果类似
    // 但你可以改成逗号或其他字符
    while ((nread = getdelim(&line, &len, ',', stdin)) != -1) {
        printf("读取到字段：%s（共 %zd 个字符）\n", line, nread);
    }

    free(line);
    return 0;
}

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

#include <stdio.h>
#include <time.h>

int main(void) {
    time_t now;

    // time() 获取当前时间
    now = time(NULL);  // NULL 表示我们不需要存储到变量，直接返回值

    printf("从 Unix 纪元到现在已经过了 %ld 秒！\n", (long)now);

    // 转换成可读的时间字符串
    printf("也就是：%s", ctime(&now));  // ctime 直接打印时间

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

int main(void) {
    time_t start, end;
    double seconds;

    start = time(NULL);

    // 模拟一些耗时操作
    printf("开始执行一个耗时的任务...\n");
    for (volatile long i = 0; i < 1000000000L; i++) {}  // 空循环，消耗 CPU 时间

    end = time(NULL);

    // difftime 计算两个 time_t 的差值（返回 double，单位秒）
    seconds = difftime(end, start);

    printf("任务完成了！\n");
    printf("实际耗时：%.2f 秒\n", seconds);

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

int main(void) {
    clock_t start, end;

    start = clock();

    // 模拟一些计算密集型任务
    long sum = 0;
    for (long i = 0; i < 1000000000L; i++) {
        sum += i;
    }

    end = clock();

    // CLOCKS_PER_SEC 是每秒包含的时钟 "刻度" 数
    double cpu_time_used = ((double)(end - start)) / CLOCKS_PER_SEC;

    printf("CPU 时间：%.6f 秒\n", cpu_time_used);
    printf("sum = %ld\n", sum);

    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

struct tm {
    int tm_sec;    // 秒（0-60，60 是闰秒）
    int tm_min;    // 分钟（0-59）
    int tm_hour;   // 小时（0-23）
    int tm_mday;   // 一个月中的第几天（1-31）
    int tm_mon;    // 月份（0-11，0 表示一月！）⚠️
    int tm_year;   // 年份，从 1900 年开始 ⚠️
    int tm_wday;   // 一周中的第几天（0-6，0 表示周日）
    int tm_yday;   // 一年中的第几天（0-365）
    int tm_isdst;  // 夏令时标志（>0=启用，0=未启用，-1=未知）
};

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

int main(void) {
    time_t now = time(NULL);

    // localtime 把 time_t 转换成 struct tm（本地时间）
    struct tm *tm_local = localtime(&now);

    printf("当前时间（分解格式）：\n");
    printf("  年份：%d\n", tm_local->tm_year + 1900);  // ⚠️ 要加 1900
    printf("  月份：%d\n", tm_local->tm_mon + 1);       // ⚠️ 要加 1
    printf("  日期：%d\n", tm_local->tm_mday);
    printf("  小时：%d\n", tm_local->tm_hour);
    printf("  分钟：%d\n", tm_local->tm_min);
    printf("  秒数：%d\n", tm_local->tm_sec);
    printf("  星期：%d（0=周日，1=周一...）\n", tm_local->tm_wday);
    printf("  一年中的第 %d 天\n", tm_local->tm_yday + 1);

    if (tm_local->tm_isdst > 0) {
        printf("  夏令时：已启用 ☀️\n");
    } else if (tm_local->tm_isdst == 0) {
        printf("  夏令时：未启用\n");
    } else {
        printf("  夏令时：未知\n");
    }

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

int main(void) {
    time_t now = time(NULL);

    struct tm *utc = gmtime(&now);
    struct tm *local = localtime(&now);

    printf("UTC 时间：%d年%d月%d日 %02d:%02d:%02d\n",
           utc->tm_year + 1900, utc->tm_mon + 1, utc->tm_mday,
           utc->tm_hour, utc->tm_min, utc->tm_sec);

    printf("本地时间：%d年%d月%d日 %02d:%02d:%02d\n",
           local->tm_year + 1900, local->tm_mon + 1, local->tm_mday,
           local->tm_hour, local->tm_min, local->tm_sec);

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

int main(void) {
    time_t now = time(NULL);
    struct tm result;
    char buf[100];

    // localtime_s 是线程安全的版本
    errno_t err = localtime_s(&result, &now);

    if (err == 0) {
        printf("本地时间：%d年%d月%d日\n",
               result.tm_year + 1900,
               result.tm_mon + 1,
               result.tm_mday);

        // 还可以顺便获取格式化字符串
        strftime(buf, sizeof(buf), "%Y-%m-%d %H:%M:%S", &result);
        printf("格式化输出：%s\n", buf);
    }

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

int main(void) {
    time_t now = time(NULL);
    struct tm *t = localtime(&now);

    char buf[200];

    // 各种格式化输出
    strftime(buf, sizeof(buf), "%Y-%m-%d", t);
    printf("日期（ISO 格式）：%s\n", buf);

    strftime(buf, sizeof(buf), "%H:%M:%S", t);
    printf("时间：%s\n", buf);

    strftime(buf, sizeof(buf), "%Y-%m-%d %H:%M:%S", t);
    printf("完整时间：%s\n", buf);

    strftime(buf, sizeof(buf), "%A, %B %d, %Y", t);
    printf("英文全写：%s\n", buf);

    strftime(buf, sizeof(buf), "今天是 %Y 年第 %j 天", t);
    printf("今天是 %s\n", buf);

    strftime(buf, sizeof(buf), "%p %I:%M %Z", t);
    printf("12小时制：%s\n", buf);

    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

#include <stdio.h>
#include <time.h>

int main(void) {
    // 构造一个特定的时间：2025年1月1日 0点0分0秒
    struct tm t = {
        .tm_sec = 0,
        .tm_min = 0,
        .tm_hour = 0,
        .tm_mday = 1,
        .tm_mon = 0,     // 0 = January！
        .tm_year = 125   // 125 = 2025 - 1900
    };

    // mktime 会自动"规范化" tm 结构体
    // 比如如果 tm_wday 填错了，它会自动计算正确的值
    time_t timestamp = mktime(&t);

    printf("2025年1月1日 0点0分0秒（本地时间）对应的 time_t：%ld\n", (long)timestamp);
    printf("转换回来：%s", ctime(&timestamp));

    // 注意：mktime 使用本地时区！
    // 如果你在北京时间（UTC+8），mktime 会把 struct tm 当作本地时间来计算

    return 0;
}

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

#include <stdio.h>
#include <time.h>

int main(void) {
    struct timespec ts;

    // TIME_UTC 是目前唯一标准化的时钟类型
    timespec_get(&ts, TIME_UTC);

    printf("当前时间（纳秒精度）：\n");
    printf("  秒：%ld\n", (long)ts.tv_sec);
    printf("  纳秒：%ld\n", (long)ts.tv_nsec);
    printf("  总秒数：%lf\n", ts.tv_sec + ts.tv_nsec / 1000000000.0);

    return 0;
}

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

#include <stdio.h>
#include <time.h>

int main(void) {
    struct timespec res;

    // 获取时钟分辨率（最小时间单位）
    timespec_getres(&res, TIME_UTC);

    printf("时钟分辨率为：%ld 秒 %ld 纳秒\n",
           (long)res.tv_sec, (long)res.tv_nsec);

    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 <time.h>
#include <string.h>
#include <errno.h>

int main(void) {
    time_t now = time(NULL);
    struct tm result;

    // localtime_s：线程安全的本地时间
    if (localtime_s(&result, &now) == 0) {
        char buf[100];
        strftime(buf, sizeof(buf), "%Y-%m-%d %H:%M:%S %Z", &result);
        printf("本地时间（线程安全）：%s\n", buf);
    }

    // gmtime_s：线程安全的 UTC 时间
    if (gmtime_s(&result, &now) == 0) {
        char buf[100];
        strftime(buf, sizeof(buf), "%Y-%m-%d %H:%M:%S UTC", &result);
        printf("UTC 时间（线程安全）：%s\n", buf);
    }

    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

#include <stdio.h>
#include <ctype.h>

int main(void) {
    char c;

    // 测试各种字符
    printf("字符分类测试：\n\n");

    c = 'A';
    printf("'%c': isalpha=%d, isupper=%d, isdigit=%d, isalnum=%d\n",
           c, isalpha(c), isupper(c), isdigit(c), isalnum(c));

    c = 'a';
    printf("'%c': isalpha=%d, islower=%d, isdigit=%d, isalnum=%d\n",
           c, isalpha(c), islower(c), isdigit(c), isalnum(c));

    c = '5';
    printf("'%c': isdigit=%d, isalpha=%d, isalnum=%d\n",
           c, isdigit(c), isalpha(c), isalnum(c));

    c = ' ';
    printf("'%c' (空格): isspace=%d, isprint=%d\n",
           c, isspace(c), isprint(c));

    c = '\n';
    printf("'\\n' (换行): isspace=%d, iscntrl=%d\n",
           c, isspace(c), iscntrl(c));

    c = '!';
    printf("'%c': ispunct=%d, isgraph=%d, isprint=%d\n",
           c, ispunct(c), isgraph(c), isprint(c));

    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

#include <stdio.h>
#include <ctype.h>

int main(void) {
    char c;

    printf("字符转换示例：\n\n");

    c = 'a';
    printf("tolower('%c') = '%c'\n", c, tolower(c));

    c = 'Z';
    printf("toupper('%c') = '%c'\n", c, toupper(c));

    c = '7';
    printf("toupper('%c') = '%c' （数字不受影响）\n", c, toupper(c));

    c = '!';
    printf("tolower('%c') = '%c' （标点不受影响）\n", c, tolower(c));

    // 实用场景：忽略大小写的字符串比较
    char s1[] = "Hello";
    char s2[] = "hello";

    // 用 tolower 实现不区分大小写的比较
    int i = 0;
    while (s1[i] && s2[i]) {
        if (tolower((unsigned char)s1[i]) != tolower((unsigned char)s2[i])) {
            printf("'%s' 和 '%s' 不相等！\n", s1, s2);
            return 0;
        }
        i++;
    }

    if (s1[i] == s2[i]) {
        printf("'%s' 和 '%s' 相等（忽略大小写）！\n", s1, s2);
    }

    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

#include <stdio.h>
#include <ctype.h>
#include <string.h>

int is_valid_username(const char *username) {
    size_t len = strlen(username);

    if (len < 3 || len > 20) {
        return 0;  // 用户名长度必须在 3-20 之间
    }

    for (size_t i = 0; i < len; i++) {
        if (!isalnum((unsigned char)username[i])) {
            return 0;  // 发现非法字符
        }
    }

    return 1;  // 所有字符都是字母或数字
}

int main(void) {
    const char *test1 = "JohnDoe123";
    const char *test2 = "Alice!@#";
    const char *test3 = "AB";

    printf("%s: %s\n", test1, is_valid_username(test1) ? "有效" : "无效");
    printf("%s: %s\n", test2, is_valid_username(test2) ? "有效" : "无效");
    printf("%s: %s\n", test3, is_valid_username(test3) ? "有效" : "无效");

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

int main(void) {
    double angle = M_PI / 4;  // 45 度（注意：C 里的角度单位是弧度！）

    printf("三角函数示例（45度 = π/4 弧度）：\n\n");

    printf("sin(π/4) = %f\n", sin(angle));
    printf("cos(π/4) = %f\n", cos(angle));
    printf("tan(π/4) = %f\n", tan(angle));

    printf("\n反三角函数：\n");
    printf("asin(0.707) = %f 弧度 = %f 度\n", asin(0.707), asin(0.707) * 180 / M_PI);
    printf("acos(0.707) = %f 弧度 = %f 度\n", acos(0.707), acos(0.707) * 180 / M_PI);
    printf("atan(1.0) = %f 弧度 = %f 度\n", atan(1.0), atan(1.0) * 180 / M_PI);

    return 0;
}

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

#include <stdio.h>
#include <math.h>

int main(void) {
    double x = 1.0;

    printf("双曲函数示例（x = 1）：\n\n");

    printf("sinh(1) = %f\n", sinh(x));  // 双曲正弦
    printf("cosh(1) = %f\n", cosh(x));  // 双曲余弦
    printf("tanh(1) = %f\n", tanh(x));  // 双曲正切

    // 验证双曲恒等式
    printf("\n验证 cosh²(x) - sinh²(x) = 1：\n");
    printf("%f² - %f² = %f\n", cosh(x), sinh(x), cosh(x)*cosh(x) - sinh(x)*sinh(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
30
31

#include <stdio.h>
#include <math.h>

int main(void) {
    double x = 2.0;

    printf("指数和对数函数示例：\n\n");

    // exp(x) = e^x
    printf("exp(1) = e^1 = %f\n", exp(1.0));
    printf("exp(2) = e^2 = %f\n", exp(2.0));

    // log(x) = ln(x)（自然对数）
    printf("log(e) = ln(e) = %f\n", log(M_E));
    printf("log(10) = ln(10) = %f\n", log(10.0));

    // log10(x) = 以 10 为底的对数
    printf("log10(100) = %f\n", log10(100.0));

    // log2(x) = 以 2 为底的对数
    printf("log2(1024) = %f\n", log2(1024.0));

    // pow(x, y) = x^y
    printf("pow(2, 10) = 2^10 = %f\n", pow(2.0, 10.0));
    printf("pow(9, 0.5) = 9^0.5 = %f\n", pow(9.0, 0.5));

    // sqrt(x) = x 的平方根
    printf("sqrt(16) = %f\n", sqrt(16.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

#include <stdio.h>
#include <math.h>

int main(void) {
    double x = 3.7;
    double y = -3.7;

    printf("四舍五入和取整函数示例：\n\n");

    printf("原数值：x = %.1f, y = %.1f\n\n", x, y);

    printf("ceil（向上取整）：\n");
    printf("  ceil(%.1f) = %.1f\n", x, ceil(x));
    printf("  ceil(%.1f) = %.1f\n", y, ceil(y));

    printf("floor（向下取整）：\n");
    printf("  floor(%.1f) = %.1f\n", x, floor(x));
    printf("  floor(%.1f) = %.1f\n", y, floor(y));

    printf("round（四舍五入）：\n");
    printf("  round(%.1f) = %.1f\n", x, round(x));
    printf("  round(%.1f) = %.1f\n", y, round(y));

    printf("trunc（截断，向零取整）：\n");
    printf("  trunc(%.1f) = %.1f\n", x, trunc(x));
    printf("  trunc(%.1f) = %.1f\n", y, trunc(y));

    printf("rint（根据当前舍入模式四舍五入）：\n");
    printf("  rint(%.1f) = %.1f\n", x, rint(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
30
31
32
33
34
35
36
37