10111000 00000101 00000000 00000000 00000000

mov eax, 5

int a = 5;

  编写源代码               编译                     运行
 hello.c（文本文件） ────────────▶ hello.exe（可执行程序） ────────▶ 屏幕上显示结果

   pacman -S --needed base-devel mingw-w64-ucrt-x86_64-toolchain

xcode-select --install

# Ubuntu / Debian
sudo apt update
sudo apt install build-essential gdb

# Fedora
sudo dnf install gcc gdb

# Arch Linux
sudo pacman -S base-devel gdb

#include <stdio.h>

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

Hello, World!

$ gcc hello.c -o hello
$ ./hello
Hello, World!

$ gcc -Wall -Wextra -std=c11 -g hello.c -o hello

hello.c ──预处理──▶ hello.i ──编译──▶ hello.s ──汇编──▶ hello.o ──链接──▶ hello
 源代码            展开后的源代码       汇编代码           目标文件           可执行程序

$ gcc -E hello.c -o hello.i    # 只预处理
$ gcc -S hello.i -o hello.s    # 编译成汇编代码
$ gcc -c hello.s -o hello.o    # 汇编成目标文件
$ gcc hello.o -o hello         # 链接成可执行程序

// 单行注释：从 // 开始，直到这一行结束

/* 多行注释：从斜杠星号开始，
   到星号斜杠结束，
   中间可以跨越多行 */

i = i + 1;   // i 加 1                 ← 废话，代码本身已经说明了
i = i + 1;   // 跳过第一行的表头        ← 有用，说明了意图

文件名:行号:列号: error: 错误描述

      *
     ***
    *****
   *******

地址      0x1000   0x1001   0x1002   0x1003   0x1004  ...
        +--------+--------+--------+--------+--------+
内容    |01001000|01101001|00000000|11111111|00101010| ...
        +--------+--------+--------+--------+--------+

#include <stdio.h>

int main(void)
{
    int age = 18;            // 定义整数变量 age，并初始化为 18
    double height = 1.75;    // 定义小数变量 height
    char grade = 'A';        // 定义字符变量 grade

    printf("年龄：%d\n", age);
    printf("身高：%.2f 米\n", height);
    printf("等级：%c\n", grade);

    age = 19;                // 给变量赋一个新值
    printf("明年的年龄：%d\n", age);
    return 0;
}

年龄：18
身高：1.75 米
等级：A
明年的年龄：19

int sum;          // 没有初始化，sum 的值不确定
sum = sum + 10;   // 结果不可预测！

#include <stdio.h>

int main(void)
{
    printf("char        : %zu 字节\n", sizeof(char));
    printf("short       : %zu 字节\n", sizeof(short));
    printf("int         : %zu 字节\n", sizeof(int));
    printf("long        : %zu 字节\n", sizeof(long));
    printf("long long   : %zu 字节\n", sizeof(long long));
    printf("float       : %zu 字节\n", sizeof(float));
    printf("double      : %zu 字节\n", sizeof(double));
    printf("long double : %zu 字节\n", sizeof(long double));
    return 0;
}

char        : 1 字节
short       : 2 字节
int         : 4 字节
long        : 8 字节
long long   : 8 字节
float       : 4 字节
double      : 8 字节
long double : 16 字节

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

int main(void)
{
    printf("int 的范围：%d ~ %d\n", INT_MIN, INT_MAX);
    printf("unsigned int 的最大值：%u\n", UINT_MAX);
    printf("long long 的范围：%lld ~ %lld\n", LLONG_MIN, LLONG_MAX);
    printf("float 的有效数字：%d 位\n", FLT_DIG);
    printf("double 的有效数字：%d 位\n", DBL_DIG);
    return 0;
}

int 的范围：-2147483648 ~ 2147483647
unsigned int 的最大值：4294967295
long long 的范围：-9223372036854775808 ~ 9223372036854775807
float 的有效数字：6 位
double 的有效数字：15 位

+5 的原码：0000 0101
-5 的原码：1000 0101

+5：           0000 0101
按位取反：      1111 1010
再加 1：        1111 1011    ← 这就是 -5 的补码

double a = 3.14;       // 普通写法
double b = 1.5e3;      // 科学计数法：1.5 × 10³ = 1500.0
double c = 2.5E-3;     // 2.5 × 10⁻³ = 0.0025
float  d = 3.14f;      // 带 f 后缀表示 float 类型

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

int main(void)
{
    double a = 0.1 + 0.2;
    printf("0.1 + 0.2 = %.17f\n", a);
    printf("a == 0.3 的结果：%d\n", a == 0.3);
    printf("误差足够小吗：%d\n", fabs(a - 0.3) < 1e-9);

    float f = 1.0f / 3;
    double d = 1.0 / 3;
    printf("float  的 1/3：%.20f\n", f);
    printf("double 的 1/3：%.20f\n", d);
    return 0;
}

0.1 + 0.2 = 0.30000000000000004
a == 0.3 的结果：0
误差足够小吗：1
float  的 1/3：0.33333334326744079590
double 的 1/3：0.33333333333333331483

#include <stdio.h>

int main(void)
{
    char c = 'A';
    printf("字符 %c 的 ASCII 码是 %d\n", c, c);
    printf("ASCII 码 97 对应的字符是 %c\n", 97);
    printf("'A' + 1 得到 %c\n", c + 1);
    printf("转换成小写：%c\n", c + 32);      // 'a' - 'A' 等于 32

    char digit = '7';
    printf("字符 '7' 对应的数值：%d\n", digit - '0');
    return 0;
}

字符 A 的 ASCII 码是 65
ASCII 码 97 对应的字符是 a
'A' + 1 得到 B
转换成小写：a
字符 '7' 对应的数值：7

#include <stdio.h>
#include <stdbool.h>

int main(void)
{
    bool is_passed = true;
    bool is_excellent = false;
    printf("%d %d\n", is_passed, is_excellent);   // 输出：1 0
    return 0;
}

#include <stdio.h>

#define PI 3.14159265358979     // 宏常量

int main(void)
{
    const int DAYS_PER_WEEK = 7;   // const 常量
    double r = 2.0;

    printf("半径为 %.1f 的圆面积：%.2f\n", r, PI * r * r);
    printf("一年大约有 %d 周\n", 365 / DAYS_PER_WEEK);
    // DAYS_PER_WEEK = 8;          // 编译错误：不能修改 const 变量
    return 0;
}

半径为 2.0 的圆面积：12.57
一年大约有 52 周

#include <stdio.h>

int main(void)
{
    int n = 3.99;                  // 小数部分被截断，n 的值是 3
    double avg1 = 7 / 2;           // 7 / 2 是整数除法，结果为 3，再转换成 3.0
    double avg2 = 7.0 / 2;         // 7.0 是 double，2 被转换为 2.0，结果为 3.5
    double avg3 = (double)7 / 2;   // 强制转换，结果同样为 3.5

    printf("n = %d\n", n);
    printf("avg1 = %.1f, avg2 = %.1f, avg3 = %.1f\n", avg1, avg2, avg3);
    return 0;
}

n = 3
avg1 = 3.0, avg2 = 3.5, avg3 = 3.5

#include <stdio.h>

int main(void)
{
    int a = -1;
    unsigned int b = 1;
    printf("a < b 的结果：%d\n", a < b);   // 输出 0，也就是"假"！
    return 0;
}

   int a = 7 / 2;
   double b = 7 / 2;
   double c = 7.0 / 2;
   int d = (int)3.99;
   unsigned int e = -1;
   printf("%d %.1f %.1f %d %u\n", a, b, c, d, e);

printf("格式字符串", 参数1, 参数2, ...);

#include <stdio.h>

int main(void)
{
    int n = 42;
    double pi = 3.14159265;

    printf("[%d]\n", n);            // 原样输出
    printf("[%5d]\n", n);           // 宽度为 5，默认右对齐
    printf("[%-5d]\n", n);          // 宽度为 5，左对齐
    printf("[%05d]\n", n);          // 宽度为 5，左边补 0
    printf("[%+d]\n", n);           // 显示正号
    printf("[%f]\n", pi);           // 默认 6 位小数
    printf("[%.2f]\n", pi);         // 保留 2 位小数
    printf("[%8.3f]\n", pi);        // 总宽度 8，保留 3 位小数
    printf("[%e]\n", 123456.789);   // 科学计数法
    printf("[%x] [%X] [%o]\n", 255, 255, 8);
    printf("[%.3s]\n", "Hello");    // 字符串最多输出 3 个字符
    printf("[100%%]\n");            // 输出 % 本身
    return 0;
}

[42]
[   42]
[42   ]
[00042]
[+42]
[3.141593]
[3.14]
[   3.142]
[1.234568e+05]
[ff] [FF] [10]
[Hel]
[100%]

#include <stdio.h>

int main(void)
{
    printf("%-10s%6s%10s\n", "Item", "Qty", "Price");
    printf("%-10s%6d%10.2f\n", "Apple", 3, 4.5);
    printf("%-10s%6d%10.2f\n", "Banana", 12, 0.75);
    printf("%-10s%6d%10.2f\n", "Cherry", 100, 25.8);
    return 0;
}

Item         Qty     Price
Apple          3      4.50
Banana        12      0.75
Cherry       100     25.80

#include <stdio.h>

int main(void)
{
    int a, b;
    printf("请输入两个整数：");
    scanf("%d %d", &a, &b);
    printf("%d + %d = %d\n", a, b, a + b);
    return 0;
}

请输入两个整数：3 5
3 + 5 = 8

#include <stdio.h>

int main(void)
{
    int n = 0;
    printf("请输入一个整数：");
    int count = scanf("%d", &n);
    printf("scanf 成功读取了 %d 个数据，n = %d\n", count, n);
    return 0;
}

请输入一个整数：25
scanf 成功读取了 1 个数据，n = 25

请输入一个整数：abc
scanf 成功读取了 0 个数据，n = 0

#include <stdio.h>

int main(void)
{
    int age;
    char grade;

    printf("请输入年龄：");
    scanf("%d", &age);
    printf("请输入等级：");
    scanf("%c", &grade);
    printf("年龄 = %d，等级 = [%c]\n", age, grade);
    return 0;
}

请输入年龄：18
请输入等级：年龄 = 18，等级 = [
]

int ch;
while ((ch = getchar()) != '\n' && ch != EOF) {
    // 循环体为空：只是把这一行剩下的字符逐个读走、丢弃
}

#include <stdio.h>

int main(void)
{
    printf("请输入一个小写字母：");
    int ch = getchar();
    printf("它的 ASCII 码是 %d，对应的大写字母是 ", ch);
    putchar(ch - 32);
    putchar('\n');
    return 0;
}

请输入一个小写字母：b
它的 ASCII 码是 98，对应的大写字母是 B

#include <stdio.h>

int main(void)
{
    double weight, height;

    printf("请输入体重（千克）：");
    scanf("%lf", &weight);
    printf("请输入身高（米）：");
    scanf("%lf", &height);

    double bmi = weight / (height * height);
    printf("你的 BMI 指数是：%.1f\n", bmi);
    return 0;
}

请输入体重（千克）：65
请输入身高（米）：1.75
你的 BMI 指数是：21.2

#include <stdio.h>

int main(void)
{
    printf("7 / 2 = %d\n", 7 / 2);
    printf("-7 / 2 = %d\n", -7 / 2);
    printf("7 %% 3 = %d\n", 7 % 3);
    printf("-7 %% 3 = %d\n", -7 % 3);
    printf("7 %% -3 = %d\n", 7 % -3);
    printf("7.0 / 2 = %.1f\n", 7.0 / 2);
    return 0;
}

7 / 2 = 3
-7 / 2 = -3
7 % 3 = 1
-7 % 3 = -1
7 % -3 = 1
7.0 / 2 = 3.5

#include <stdio.h>

int main(void)
{
    int money;
    printf("请输入金额（元）：");
    scanf("%d", &money);

    int n100 = money / 100;
    money %= 100;              // 剩下不足 100 元的部分
    int n50 = money / 50;
    money %= 50;
    int n20 = money / 20;
    money %= 20;
    int n10 = money / 10;
    money %= 10;
    int n5 = money / 5;
    money %= 5;
    int n1 = money;

    printf("100元 %d 张，50元 %d 张，20元 %d 张，10元 %d 张，5元 %d 张，1元 %d 张\n",
           n100, n50, n20, n10, n5, n1);
    return 0;
}

请输入金额（元）：388
100元 3 张，50元 1 张，20元 1 张，10元 1 张，5元 1 张，1元 3 张

#include <stdio.h>

int main(void)
{
    int i = 5;
    int a = i++;    // a 得到 5，然后 i 变成 6
    printf("a = %d, i = %d\n", a, i);

    int b = ++i;    // i 先变成 7，b 得到 7
    printf("b = %d, i = %d\n", b, i);

    int c = i--;    // c 得到 7，然后 i 变成 6
    int d = --i;    // i 先变成 5，d 得到 5
    printf("c = %d, d = %d, i = %d\n", c, d, i);
    return 0;
}

a = 5, i = 6
b = 7, i = 7
c = 7, d = 5, i = 5

#include <stdio.h>

int main(void)
{
    int a = 0, b = 5;
    int r = (a != 0) && (b / a > 1);   // a != 0 为假，右边不会计算，也就不会除以 0
    printf("r = %d\n", r);

    int x = 1;
    int y = (x > 0) || (++x > 0);      // 左边已经为真，++x 不会执行
    printf("y = %d, x = %d\n", y, x);
    return 0;
}

r = 0
y = 1, x = 1

#include <stdio.h>

int main(void)
{
    int year;
    printf("请输入年份：");
    scanf("%d", &year);

    int is_leap = (year % 4 == 0 && year % 100 != 0) || year % 400 == 0;
    printf("%d 年是闰年吗？%d\n", year, is_leap);
    return 0;
}

请输入年份：2024
2024 年是闰年吗？1

条件 ? 表达式1 : 表达式2

int max = (a > b) ? a : b;                        // 取 a、b 中的较大者
printf("%d 是%s数\n", n, (n % 2 == 0) ? "偶" : "奇");

int a, b;
a = (b = 3, b + 2);   // 先执行 b = 3，再计算 b + 2，a 的值是 5

int n = 10;
printf("%zu %zu %zu\n", sizeof(int), sizeof(n), sizeof n);   // 输出：4 4 4

   int a = 5, b = 3;
   printf("%d %d %d %d\n", a / b, a % b, -a / b, -a % b);
   int x = 0, y = 0;
   int r = (x++ > 0) && (y++ > 0);
   printf("%d %d %d\n", r, x, y);

if (条件) {
    语句块    // 条件为真时执行
}

            条件为真吗？
           /            \
         是              否
         |                |
     执行语句块            |
          \              /
          继续执行后面的语句

#include <stdio.h>

int main(void)
{
    int n;
    printf("请输入一个整数：");
    scanf("%d", &n);

    if (n < 0) {
        n = -n;
    }
    printf("它的绝对值是 %d\n", n);
    return 0;
}

请输入一个整数：-7
它的绝对值是 7

if (score >= 60)
    printf("及格了\n");
    printf("恭喜你！\n");    // 这一行并不属于 if，无论是否及格都会执行！

if (条件) {
    语句块1    // 条件为真时执行
} else {
    语句块2    // 条件为假时执行
}

#include <stdio.h>

int main(void)
{
    int n;
    printf("请输入一个整数：");
    scanf("%d", &n);

    if (n % 2 == 0) {
        printf("%d 是偶数\n", n);
    } else {
        printf("%d 是奇数\n", n);
    }
    return 0;
}

请输入一个整数：17
17 是奇数

if (条件1) {
    语句块1
} else if (条件2) {
    语句块2
} else if (条件3) {
    语句块3
} else {
    语句块4    // 以上条件都不满足时执行
}

#include <stdio.h>

int main(void)
{
    int score;
    printf("请输入成绩（0~100）：");
    if (scanf("%d", &score) != 1 || score < 0 || score > 100) {
        printf("输入无效！\n");
        return 1;
    }

    char grade;
    if (score >= 90) {
        grade = 'A';
    } else if (score >= 80) {
        grade = 'B';
    } else if (score >= 70) {
        grade = 'C';
    } else if (score >= 60) {
        grade = 'D';
    } else {
        grade = 'E';
    }
    printf("等级：%c\n", grade);
    return 0;
}

请输入成绩（0~100）：85
等级：B

if (a > 0)
    if (b > 0)
        printf("a 和 b 都是正数\n");
else
    printf("a 不是正数\n");

if (a > 0) {
    if (b > 0) {
        printf("a 和 b 都是正数\n");
    }
} else {
    printf("a 不是正数\n");
}

switch (表达式) {
case 常量1:
    语句块1
    break;
case 常量2:
    语句块2
    break;
default:
    语句块3
    break;
}

#include <stdio.h>

int main(void)
{
    double a, b;
    char op;
    printf("请输入算式（如 3 + 4）：");
    scanf("%lf %c %lf", &a, &op, &b);

    switch (op) {
    case '+':
        printf("%g %c %g = %g\n", a, op, b, a + b);
        break;
    case '-':
        printf("%g %c %g = %g\n", a, op, b, a - b);
        break;
    case '*':
        printf("%g %c %g = %g\n", a, op, b, a * b);
        break;
    case '/':
        if (b == 0) {
            printf("错误：除数不能为 0\n");
        } else {
            printf("%g %c %g = %g\n", a, op, b, a / b);
        }
        break;
    default:
        printf("不支持的运算符：%c\n", op);
        break;
    }
    return 0;
}

请输入算式（如 3 + 4）：10 / 4
10 / 4 = 2.5

#include <stdio.h>

int main(void)
{
    int level = 2;
    switch (level) {
    case 1:
        printf("一级\n");
    case 2:
        printf("二级\n");
    case 3:
        printf("三级\n");
    default:
        printf("其他\n");
    }
    return 0;
}

二级
三级
其他

switch (month) {
case 3: case 4: case 5:
    printf("春季\n");
    break;
case 6: case 7: case 8:
    printf("夏季\n");
    break;
case 9: case 10: case 11:
    printf("秋季\n");
    break;
case 12: case 1: case 2:
    printf("冬季\n");
    break;
default:
    printf("月份输入有误\n");
    break;
}

switch (score / 10) {
case 10:
case 9:
    grade = 'A';
    break;
case 8:
    grade = 'B';
    break;
case 7:
    grade = 'C';
    break;
case 6:
    grade = 'D';
    break;
default:
    grade = 'E';
    break;
}

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

int main(void)
{
    double a, b, c;
    printf("请输入 ax^2 + bx + c = 0 的系数 a b c：");
    if (scanf("%lf %lf %lf", &a, &b, &c) != 3) {
        printf("输入无效！\n");
        return 1;
    }

    if (fabs(a) < 1e-12) {
        printf("a 不能为 0，这不是一元二次方程。\n");
        return 1;
    }

    double delta = b * b - 4 * a * c;
    if (delta > 1e-12) {
        double x1 = (-b + sqrt(delta)) / (2 * a);
        double x2 = (-b - sqrt(delta)) / (2 * a);
        printf("有两个不相等的实根：x1 = %.2f, x2 = %.2f\n", x1, x2);
    } else if (delta >= -1e-12) {
        printf("有两个相等的实根：x1 = x2 = %.2f\n", -b / (2 * a));
    } else {
        double real = -b / (2 * a);
        double imag = fabs(sqrt(-delta) / (2 * a));
        printf("有两个共轭复根：x1 = %.2f + %.2fi, x2 = %.2f - %.2fi\n",
               real, imag, real, imag);
    }
    return 0;
}

请输入 ax^2 + bx + c = 0 的系数 a b c：1 -3 2
有两个不相等的实根：x1 = 2.00, x2 = 1.00

请输入 ax^2 + bx + c = 0 的系数 a b c：1 2 1
有两个相等的实根：x1 = x2 = -1.00

请输入 ax^2 + bx + c = 0 的系数 a b c：1 2 5
有两个共轭复根：x1 = -1.00 + 2.00i, x2 = -1.00 - 2.00i

while (条件) {
    循环体
}

     ┌──▶ 条件为真吗？ ──否──▶ 结束循环
     │         │
     │         是
     │         ▼
     └───── 执行循环体

#include <stdio.h>

int main(void)
{
    int i = 1;            // ① 初始化循环变量
    int sum = 0;
    while (i <= 100) {    // ② 循环条件
        sum += i;
        i++;              // ③ 更新循环变量
    }
    printf("1 + 2 + ... + 100 = %d\n", sum);
    return 0;
}

1 + 2 + ... + 100 = 5050

#include <stdio.h>

int main(void)
{
    int n;
    printf("请输入一个正整数：");
    scanf("%d", &n);

    int digits = 0, sum = 0;
    int temp = n;           // 用副本进行计算，保留 n 的原值
    while (temp > 0) {
        sum += temp % 10;   // 取出个位
        temp /= 10;         // 去掉个位
        digits++;
    }
    printf("%d 是 %d 位数，各位数字之和为 %d\n", n, digits, sum);
    return 0;
}

请输入一个正整数：2024
2024 是 4 位数，各位数字之和为 8

do {
    循环体
} while (条件);    // 注意末尾有分号

do {
    sum += temp % 10;
    temp /= 10;
    digits++;
} while (temp != 0);

#include <stdio.h>

int main(void)
{
    int score = -1;
    int ok;
    do {
        printf("请输入成绩（0~100）：");
        ok = scanf("%d", &score);
        if (ok == EOF) {
            return 1;                  // 输入已结束，直接退出
        }
        int ch;
        while ((ch = getchar()) != '\n' && ch != EOF) {
            // 清空这一行剩余的输入
        }
    } while (ok != 1 || score < 0 || score > 100);

    printf("你输入的成绩是 %d\n", score);
    return 0;
}

请输入成绩（0~100）：abc
请输入成绩（0~100）：120
请输入成绩（0~100）：95
你输入的成绩是 95

for (初始化; 条件; 更新) {
    循环体
}

① 初始化 → ② 判断条件 → ③ 执行循环体 → ④ 更新 → ② 判断条件 → ③ → ④ → … → 条件为假时结束

#include <stdio.h>

int main(void)
{
    int n;
    printf("请输入 n（0~20）：");
    scanf("%d", &n);

    long long result = 1;
    for (int i = 2; i <= n; i++) {
        result *= i;
    }
    printf("%d! = %lld\n", n, result);
    return 0;
}

请输入 n（0~20）：20
20! = 2432902008176640000

for (int i = 0, j = 9; i < j; i++, j--) {
    printf("(%d, %d) ", i, j);   // 输出 (0, 9) (1, 8) (2, 7) (3, 6) (4, 5)
}

#include <stdio.h>

int main(void)
{
    // continue：输出 1~20 中不是 3 的倍数的数
    for (int i = 1; i <= 20; i++) {
        if (i % 3 == 0) {
            continue;
        }
        printf("%d ", i);
    }
    printf("\n");

    // break：找出大于 100 的第一个 7 的倍数
    int n = 101;
    while (1) {
        if (n % 7 == 0) {
            break;
        }
        n++;
    }
    printf("大于 100 的第一个 7 的倍数是 %d\n", n);
    return 0;
}

1 2 4 5 7 8 10 11 13 14 16 17 19 20
大于 100 的第一个 7 的倍数是 105

#include <stdio.h>

int main(void)
{
    for (int i = 1; i <= 9; i++) {
        for (int j = 1; j <= i; j++) {
            printf("%d*%d=%-3d", j, i, i * j);
        }
        printf("\n");
    }
    return 0;
}

1*1=1
1*2=2  2*2=4
1*3=3  2*3=6  3*3=9
1*4=4  2*4=8  3*4=12 4*4=16
1*5=5  2*5=10 3*5=15 4*5=20 5*5=25
1*6=6  2*6=12 3*6=18 4*6=24 5*6=30 6*6=36
1*7=7  2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49
1*8=8  2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64
1*9=9  2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81

#include <stdio.h>

int main(void)
{
    int n = 5;
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= n - i; j++) {
            printf(" ");
        }
        for (int j = 1; j <= 2 * i - 1; j++) {
            printf("*");
        }
        printf("\n");
    }
    return 0;
}

    *
   ***
  *****
 *******
*********

#include <stdio.h>
#include <stdbool.h>

int main(void)
{
    int n;
    printf("请输入一个正整数：");
    scanf("%d", &n);

    bool is_prime = (n >= 2);          // 小于 2 的数不是素数
    for (int i = 2; i * i <= n; i++) {  // 用 i * i <= n 代替 i <= sqrt(n)，避免浮点运算
        if (n % i == 0) {
            is_prime = false;
            break;                     // 已经找到因数，没必要继续检查
        }
    }
    printf("%d %s素数\n", n, is_prime ? "是" : "不是");
    return 0;
}

请输入一个正整数：97
97 是素数

#include <stdio.h>

int main(void)
{
    int a, b;
    printf("请输入两个正整数：");
    scanf("%d %d", &a, &b);

    int x = a, y = b;
    while (y != 0) {
        int r = x % y;
        x = y;
        y = r;
    }
    printf("%d 和 %d 的最大公约数是 %d\n", a, b, x);
    return 0;
}

请输入两个正整数：48 18
48 和 18 的最大公约数是 6

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

int main(void)
{
    srand((unsigned int)time(NULL));   // 用当前时间作为随机数种子
    int target = rand() % 100 + 1;     // 生成 1~100 之间的随机整数
    int guess;
    int count = 0;

    printf("我想了一个 1~100 之间的数，猜猜是几？\n");
    do {
        printf("请输入你的猜测：");
        if (scanf("%d", &guess) != 1) {
            printf("输入无效，游戏结束。\n");
            return 1;
        }
        count++;
        if (guess > target) {
            printf("太大了！\n");
        } else if (guess < target) {
            printf("太小了！\n");
        }
    } while (guess != target);

    printf("恭喜你猜对了！答案是 %d，你一共猜了 %d 次。\n", target, count);
    return 0;
}

我想了一个 1~100 之间的数，猜猜是几？
请输入你的猜测：50
太大了！
请输入你的猜测：25
太小了！
请输入你的猜测：37
太小了！
请输入你的猜测：43
恭喜你猜对了！答案是 43，你一共猜了 4 次。

#include <stdio.h>

int main(void)
{
    for (int i = 1; i < 10; i++) {
        for (int j = 1; j < 10; j++) {
            if (i * j == 42) {
                printf("找到了：%d * %d = 42\n", i, j);
                goto found;
            }
        }
    }
found:
    printf("搜索结束\n");
    return 0;
}

找到了：6 * 7 = 42
搜索结束

     *
    ***
   *****
    ***
     *

返回类型 函数名(参数列表)
{
    函数体
}

#include <stdio.h>

// 返回 a 和 b 中较大的那个
int max(int a, int b)
{
    if (a > b) {
        return a;
    }
    return b;
}

int main(void)
{
    int x = 3, y = 7;
    int m = max(x, y);                           // 调用 max 函数
    printf("较大的是 %d\n", m);
    printf("较大的是 %d\n", max(10, max(4, 12)));  // 函数调用可以嵌套
    return 0;
}

较大的是 7
较大的是 12

void print_line(int length)
{
    for (int i = 0; i < length; i++) {
        putchar('-');
    }
    putchar('\n');
}

#include <stdio.h>

double circle_area(double r);   // 函数声明，末尾有分号

int main(void)
{
    printf("面积：%.2f\n", circle_area(2.0));
    return 0;
}

double circle_area(double r)     // 函数定义
{
    return 3.14159265358979 * r * r;
}

面积：12.57

#include <stdio.h>

void swap(int a, int b)
{
    int temp = a;
    a = b;
    b = temp;
    printf("函数内：a = %d, b = %d\n", a, b);
}

int main(void)
{
    int x = 1, y = 2;
    swap(x, y);
    printf("函数外：x = %d, y = %d\n", x, y);
    return 0;
}

函数内：a = 2, b = 1
函数外：x = 1, y = 2

main 函数的变量           swap 函数的变量
+-------+-------+        +-------+-------+
| x = 1 | y = 2 |  复制   | a = 1 | b = 2 |   交换后 → a = 2, b = 1
+-------+-------+  ───▶  +-------+-------+
   原件不受影响                复印件被修改

#include <stdio.h>

int g_count = 0;          // 全局变量

void add(void)
{
    g_count++;            // 任何函数都能访问全局变量
}

int main(void)
{
    int x = 10;           // 局部变量，只在 main 中有效
    {
        int x = 20;       // 内层代码块中的 x，"遮蔽"了外层的 x
        printf("内层 x = %d\n", x);
    }
    printf("外层 x = %d\n", x);

    add();
    add();
    printf("g_count = %d\n", g_count);
    return 0;
}

内层 x = 20
外层 x = 10
g_count = 2

#include <stdio.h>

void counter(void)
{
    static int count = 0;   // 静态局部变量：只初始化一次，函数返回后依然保留
    int normal = 0;         // 普通局部变量：每次调用都重新创建并初始化
    count++;
    normal++;
    printf("count = %d, normal = %d\n", count, normal);
}

int main(void)
{
    counter();
    counter();
    counter();
    return 0;
}

count = 1, normal = 1
count = 2, normal = 1
count = 3, normal = 1

#include <stdio.h>

long long factorial(int n)
{
    if (n <= 1) {                    // 终止条件
        return 1;
    }
    return n * factorial(n - 1);     // 递推关系
}

int main(void)
{
    for (int i = 0; i <= 5; i++) {
        printf("%d! = %lld\n", i, factorial(i));
    }
    return 0;
}

0! = 1
1! = 1
2! = 2
3! = 6
4! = 24
5! = 120

factorial(4)
= 4 * factorial(3)
= 4 * (3 * factorial(2))
= 4 * (3 * (2 * factorial(1)))
= 4 * (3 * (2 * 1))          ← 到达终止条件，开始逐层返回
= 4 * (3 * 2)
= 4 * 6
= 24

#include <stdio.h>

long long g_calls = 0;   // 记录递归函数被调用的次数

long long fib_recursive(int n)
{
    g_calls++;
    if (n <= 2) {
        return 1;
    }
    return fib_recursive(n - 1) + fib_recursive(n - 2);
}

long long fib_loop(int n)
{
    long long a = 1, b = 1;
    for (int i = 3; i <= n; i++) {
        long long c = a + b;
        a = b;
        b = c;
    }
    return b;
}

int main(void)
{
    int n = 40;
    printf("循环版：fib(%d) = %lld\n", n, fib_loop(n));
    printf("递归版：fib(%d) = %lld\n", n, fib_recursive(n));
    printf("递归版一共调用了 %lld 次函数\n", g_calls);
    return 0;
}

循环版：fib(40) = 102334155
递归版：fib(40) = 102334155
递归版一共调用了 204668309 次函数

                    fib(5)
                  /        \
             fib(4)          fib(3)
            /      \         /     \
        fib(3)    fib(2)  fib(2)  fib(1)
        /    \
    fib(2)  fib(1)

#include <stdio.h>

// 把 n 个盘子从 from 柱移动到 to 柱，via 为辅助柱
void hanoi(int n, char from, char via, char to)
{
    if (n == 1) {
        printf("把 1 号盘从 %c 移到 %c\n", from, to);
        return;
    }
    hanoi(n - 1, from, to, via);
    printf("把 %d 号盘从 %c 移到 %c\n", n, from, to);
    hanoi(n - 1, via, from, to);
}

int main(void)
{
    hanoi(3, 'A', 'B', 'C');
    return 0;
}

把 1 号盘从 A 移到 C
把 2 号盘从 A 移到 B
把 1 号盘从 C 移到 B
把 3 号盘从 A 移到 C
把 1 号盘从 B 移到 A
把 2 号盘从 B 移到 C
把 1 号盘从 A 移到 C

      +-----------------------+
栈顶  | factorial(1) 的栈帧    |  ← 正在执行
      +-----------------------+
      | factorial(2) 的栈帧    |  等待 factorial(1) 返回
      +-----------------------+
      | factorial(3) 的栈帧    |  等待 factorial(2) 返回
      +-----------------------+
栈底  | main 的栈帧            |  等待 factorial(3) 返回
      +-----------------------+

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

int main(void)
{
    printf("sqrt(2)     = %.4f\n", sqrt(2.0));    // 平方根
    printf("pow(2, 10)  = %.0f\n", pow(2, 10));   // 幂运算
    printf("fabs(-3.5)  = %.1f\n", fabs(-3.5));   // 绝对值
    printf("ceil(2.1)   = %.0f\n", ceil(2.1));    // 向上取整
    printf("floor(2.9)  = %.0f\n", floor(2.9));   // 向下取整
    printf("round(2.5)  = %.0f\n", round(2.5));   // 四舍五入
    printf("log10(1000) = %.1f\n", log10(1000));  // 常用对数
    return 0;
}

sqrt(2)     = 1.4142
pow(2, 10)  = 1024
fabs(-3.5)  = 3.5
ceil(2.1)   = 3
floor(2.9)  = 2
round(2.5)  = 3
log10(1000) = 3.0

int scores[50];    // 一次性定义 50 个 int 类型的"格子"

int a[5] = {1, 2, 3, 4, 5};         // 完整初始化
int b[5] = {1, 2};                  // 部分初始化，其余元素自动为 0：{1, 2, 0, 0, 0}
int c[5] = {0};                     // 全部初始化为 0，这是最常用的清零写法
int d[] = {10, 20, 30};             // 省略长度，由初始值的个数决定，长度为 3
int e[10] = {[2] = 5, [7] = 9};     // C99 指定初始化：e[2] 为 5，e[7] 为 9，其余为 0

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

#include <stdio.h>

#define N 5

int main(void)
{
    int scores[N];
    printf("请输入 %d 个成绩：", N);
    for (int i = 0; i < N; i++) {
        scanf("%d", &scores[i]);
    }

    int sum = 0;
    int max_index = 0;             // 记录最高分的下标
    for (int i = 0; i < N; i++) {
        sum += scores[i];
        if (scores[i] > scores[max_index]) {
            max_index = i;
        }
    }

    printf("总分：%d\n", sum);
    printf("平均分：%.2f\n", (double)sum / N);
    printf("最高分：%d（第 %d 个）\n", scores[max_index], max_index + 1);
    return 0;
}

请输入 5 个成绩：78 92 85 66 90
总分：411
平均分：82.20
最高分：92（第 2 个）

#include <stdio.h>

int main(void)
{
    int a[5] = {10, 20, 30, 40, 50};
    for (int i = 0; i < 5; i++) {
        printf("a[%d] = %d，地址：%p\n", i, a[i], (void *)&a[i]);
    }
    return 0;
}

a[0] = 10，地址：0x7ffd5e3c8a10
a[1] = 20，地址：0x7ffd5e3c8a14
a[2] = 30，地址：0x7ffd5e3c8a18
a[3] = 40，地址：0x7ffd5e3c8a1c
a[4] = 50，地址：0x7ffd5e3c8a20

   a[0]     a[1]     a[2]     a[3]     a[4]
+--------+--------+--------+--------+--------+
|   10   |   20   |   30   |   40   |   50   |
+--------+--------+--------+--------+--------+
 ...8a10  ...8a14  ...8a18  ...8a1c  ...8a20

for (int i = 0, j = n - 1; i < j; i++, j--) {
    int temp = a[i];
    a[i] = a[j];
    a[j] = temp;
}

#include <stdio.h>

int main(void)
{
    int scores[] = {95, 82, 67, 45, 78, 88, 91, 100, 59, 73, 84, 66};
    int n = sizeof(scores) / sizeof(scores[0]);
    int counts[11] = {0};   // counts[k] 记录 k*10 ~ k*10+9 分的人数，counts[10] 记录满分

    for (int i = 0; i < n; i++) {
        counts[scores[i] / 10]++;
    }

    printf("90~100 分：%d 人\n", counts[9] + counts[10]);
    for (int k = 8; k >= 6; k--) {
        printf("%d~%d 分：%d 人\n", k * 10, k * 10 + 9, counts[k]);
    }
    int fail = 0;
    for (int k = 0; k < 6; k++) {
        fail += counts[k];
    }
    printf("不及格：%d 人\n", fail);
    return 0;
}

90~100 分：3 人
80~89 分：3 人
70~79 分：2 人
60~69 分：2 人
不及格：2 人

#include <stdio.h>

void print_array(const int arr[], int n)
{
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
}

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

int main(void)
{
    int a[] = {1, 2, 3, 4, 5};
    int n = sizeof(a) / sizeof(a[0]);
    print_array(a, n);
    double_all(a, n);
    print_array(a, n);
    return 0;
}

1 2 3 4 5
2 4 6 8 10

初始：    5  2  9  1  7  3
第 1 趟： 2  5  1  7  3 [9]
第 2 趟： 2  1  5  3 [7  9]
第 3 趟： 1  2  3 [5  7  9]
第 4 趟： 1  2  3  5  7  9     ← 这一趟没有发生任何交换，说明已经有序，提前结束

#include <stdio.h>
#include <stdbool.h>

void bubble_sort(int arr[], int n)
{
    for (int i = 0; i < n - 1; i++) {           // 最多进行 n-1 趟
        bool swapped = false;
        for (int j = 0; j < n - 1 - i; j++) {   // 末尾的 i 个元素已经排好
            if (arr[j] > arr[j + 1]) {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
                swapped = true;
            }
        }
        if (!swapped) {
            break;
        }
    }
}

void print_array(const int arr[], int n)
{
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
}

int main(void)
{
    int a[] = {5, 2, 9, 1, 7, 3};
    int n = sizeof(a) / sizeof(a[0]);
    printf("排序前：");
    print_array(a, n);
    bubble_sort(a, n);
    printf("排序后：");
    print_array(a, n);
    return 0;
}

排序前：5 2 9 1 7 3
排序后：1 2 3 5 7 9

void selection_sort(int arr[], int n)
{
    for (int i = 0; i < n - 1; i++) {
        int min_index = i;                 // 假设当前位置就是最小值
        for (int j = i + 1; j < n; j++) {
            if (arr[j] < arr[min_index]) {
                min_index = j;
            }
        }
        if (min_index != i) {              // 把最小值交换到位置 i
            int temp = arr[i];
            arr[i] = arr[min_index];
            arr[min_index] = temp;
        }
    }
}

int linear_search(const int arr[], int n, int target)
{
    for (int i = 0; i < n; i++) {
        if (arr[i] == target) {
            return i;        // 找到了，返回下标
        }
    }
    return -1;               // 没找到，返回 -1
}

#include <stdio.h>

int binary_search(const int arr[], int n, int target)
{
    int low = 0, high = n - 1;
    while (low <= high) {
        int mid = low + (high - low) / 2;   // 与 (low + high) / 2 等价，但不会溢出
        if (arr[mid] == target) {
            return mid;
        } else if (arr[mid] < target) {
            low = mid + 1;                  // 目标在右半部分
        } else {
            high = mid - 1;                 // 目标在左半部分
        }
    }
    return -1;
}

int main(void)
{
    int a[] = {3, 8, 15, 23, 42, 57, 68, 91};
    int n = sizeof(a) / sizeof(a[0]);
    printf("42 的下标：%d\n", binary_search(a, n, 42));
    printf("50 的下标：%d\n", binary_search(a, n, 50));
    return 0;
}

42 的下标：4
50 的下标：-1

int scores[3][4];   // 3 行 4 列，共 12 个元素

#include <stdio.h>

#define STUDENTS 3
#define COURSES 3

int main(void)
{
    int scores[STUDENTS][COURSES] = {
        {85, 92, 78},     // 第 0 个学生的三门课成绩
        {90, 88, 95},
        {72, 65, 80}
    };

    // 每个学生的总分：固定行，遍历列
    for (int i = 0; i < STUDENTS; i++) {
        int total = 0;
        for (int j = 0; j < COURSES; j++) {
            total += scores[i][j];
        }
        printf("学生 %d 的总分：%d\n", i + 1, total);
    }

    // 每门课的平均分：固定列，遍历行
    for (int j = 0; j < COURSES; j++) {
        int sum = 0;
        for (int i = 0; i < STUDENTS; i++) {
            sum += scores[i][j];
        }
        printf("课程 %d 的平均分：%.2f\n", j + 1, (double)sum / STUDENTS);
    }
    return 0;
}

学生 1 的总分：255
学生 2 的总分：273
学生 3 的总分：217
课程 1 的平均分：82.33
课程 2 的平均分：81.67
课程 3 的平均分：84.33

  m[0][0]  m[0][1]  m[0][2]  m[1][0]  m[1][1]  m[1][2]
+--------+--------+--------+--------+--------+--------+
|        |        |        |        |        |        |
+--------+--------+--------+--------+--------+--------+
 \_______ 第 0 行 _______/ \_______ 第 1 行 _______/

void print_matrix(int m[][3], int rows)
{
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < 3; j++) {
            printf("%4d", m[i][j]);
        }
        printf("\n");
    }
}

int n;
scanf("%d", &n);
int a[n];    // 长度在运行时才确定

   1
   1 1
   1 2 1
   1 3 3 1
   1 4 6 4 1

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

int main(void)
{
    char s[] = "Hello";
    printf("s = %s\n", s);
    printf("sizeof(s) = %zu\n", sizeof(s));   // 数组占用的字节数，包含末尾的 '\0'
    printf("strlen(s) = %zu\n", strlen(s));   // 字符串的长度，不含 '\0'

    for (int i = 0; s[i] != '\0'; i++) {
        printf("s[%d] = '%c'\n", i, s[i]);
    }
    return 0;
}

s = Hello
sizeof(s) = 6
strlen(s) = 5
s[0] = 'H'
s[1] = 'e'
s[2] = 'l'
s[3] = 'l'
s[4] = 'o'

  s[0]  s[1]  s[2]  s[3]  s[4]  s[5]
+-----+-----+-----+-----+-----+-----+
| 'H' | 'e' | 'l' | 'l' | 'o' | '\0'|
+-----+-----+-----+-----+-----+-----+

char a[6] = {'H', 'e', 'l', 'l', 'o', '\0'};  // 逐个字符初始化，必须自己写 '\0'
char b[6] = "Hello";      // 用字符串初始化，编译器自动添加 '\0'
char c[] = "Hello";       // 长度自动计算为 6
char d[20] = "Hello";     // 后面剩余的元素全部是 '\0'
char e[5] = "Hello";      // 合法，但空间不够放 '\0'，e 不是一个合法的字符串！

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

int main(void)
{
    char name[20];
    printf("请输入你的名字：");
    scanf("%19s", name);                   // 数组名本身就代表地址，不需要 &

    int ch;
    while ((ch = getchar()) != '\n' && ch != EOF) {
        // 清除 scanf 留在缓冲区里的换行符
    }

    char line[100];
    printf("请输入一句话：");
    if (fgets(line, sizeof(line), stdin) != NULL) {
        line[strcspn(line, "\n")] = '\0';  // 去掉 fgets 读入的换行符
        printf("你好，%s！你说的是：[%s]\n", name, line);
    }
    return 0;
}

请输入你的名字：Tom
请输入一句话：I love C programming
你好，Tom！你说的是：[I love C programming]

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

int main(void)
{
    char dest[50] = "Hello";
    char src[] = "World";

    printf("strlen(dest) = %zu\n", strlen(dest));

    strcat(dest, ", ");
    strcat(dest, src);
    printf("拼接后：%s\n", dest);

    char copy[50];
    strcpy(copy, dest);
    printf("复制得到：%s\n", copy);

    if (strcmp("apple", "banana") < 0) {
        printf("apple 排在 banana 前面\n");
    }
    if (strcmp(dest, copy) == 0) {
        printf("dest 和 copy 的内容相同\n");
    }

    char *pos = strstr(dest, "World");   // 返回指向子串位置的指针，找不到时返回 NULL
    if (pos != NULL) {
        printf("\"World\" 出现在下标 %d 处\n", (int)(pos - dest));
    }
    return 0;
}

strlen(dest) = 5
拼接后：Hello, World
复制得到：Hello, World
apple 排在 banana 前面
dest 和 copy 的内容相同
"World" 出现在下标 7 处

char small[6];
snprintf(small, sizeof(small), "%s", copy);   // 最多写入 5 个字符和 1 个 '\0'
printf("%s\n", small);                         // 输出：Hello

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

int main(void)
{
    char text[] = "apple,banana;cherry,,date";
    char *token = strtok(text, ",;");       // 第一次调用传入字符串
    while (token != NULL) {
        printf("[%s]\n", token);
        token = strtok(NULL, ",;");         // 之后的调用传入 NULL，表示继续处理同一个字符串
    }
    return 0;
}

[apple]
[banana]
[cherry]
[date]

#include <stdio.h>

// 求字符串长度
size_t my_strlen(const char s[])
{
    size_t len = 0;
    while (s[len] != '\0') {
        len++;
    }
    return len;
}

// 复制字符串
void my_strcpy(char dest[], const char src[])
{
    int i = 0;
    while (src[i] != '\0') {
        dest[i] = src[i];
        i++;
    }
    dest[i] = '\0';      // 别忘了复制结束标记
}

// 原地反转字符串
void reverse(char s[])
{
    int len = (int)my_strlen(s);
    for (int i = 0, j = len - 1; i < j; i++, j--) {
        char temp = s[i];
        s[i] = s[j];
        s[j] = temp;
    }
}

int main(void)
{
    char a[] = "Hello, C!";
    char b[20];

    printf("长度：%zu\n", my_strlen(a));
    my_strcpy(b, a);
    printf("复制：%s\n", b);
    reverse(b);
    printf("反转：%s\n", b);
    return 0;
}

长度：9
复制：Hello, C!
反转：!C ,olleH

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

int main(void)
{
    char s[] = "Hello World 2026!";
    for (int i = 0; s[i] != '\0'; i++) {
        unsigned char c = (unsigned char)s[i];
        if (isupper(c)) {
            s[i] = (char)tolower(c);
        } else if (islower(c)) {
            s[i] = (char)toupper(c);
        }
    }
    printf("%s\n", s);
    return 0;
}

hELLO wORLD 2026!

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

int main(void)
{
    char input[] = "78xyz";
    char *end;                                 // strtol 会让 end 指向第一个未被转换的字符
    long value = strtol(input, &end, 10);      // 10 表示按十进制转换

    if (end == input) {
        printf("\"%s\" 不是数字\n", input);
    } else if (*end != '\0') {
        printf("转换出 %ld，但后面还有多余的字符 \"%s\"\n", value, end);
    } else {
        printf("转换成功：%ld\n", value);
    }
    return 0;
}

转换出 78，但后面还有多余的字符 "xyz"

char buf[50];
int year = 2026;
double score = 95.5;
snprintf(buf, sizeof(buf), "%d 年的成绩：%.1f", year, score);
puts(buf);    // 输出：2026 年的成绩：95.5

const char *date = "2026-09-26";
int y, m, d;
if (sscanf(date, "%d-%d-%d", &y, &m, &d) == 3) {
    printf("%d 年 %d 月 %d 日\n", y, m, d);    // 输出：2026 年 9 月 26 日
}

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

#define COUNT 5
#define LEN 20

int main(void)
{
    char names[COUNT][LEN] = {"Tom", "Alice", "Bob", "Diana", "Charlie"};

    // 用冒泡排序把名字按字典序排列
    for (int i = 0; i < COUNT - 1; i++) {
        for (int j = 0; j < COUNT - 1 - i; j++) {
            if (strcmp(names[j], names[j + 1]) > 0) {
                char temp[LEN];
                strcpy(temp, names[j]);
                strcpy(names[j], names[j + 1]);
                strcpy(names[j + 1], temp);
            }
        }
    }

    for (int i = 0; i < COUNT; i++) {
        printf("%s\n", names[i]);
    }
    return 0;
}

Alice
Bob
Charlie
Diana
Tom

#include <stdio.h>

int main(void)
{
    int a = 10;
    double b = 3.14;
    char c = 'X';
    printf("a 的值：%d，地址：%p\n", a, (void *)&a);
    printf("b 的值：%.2f，地址：%p\n", b, (void *)&b);
    printf("c 的值：%c，地址：%p\n", c, (void *)&c);
    return 0;
}

a 的值：10，地址：0x7ffe3b1a5c3c
b 的值：3.14，地址：0x7ffe3b1a5c40
c 的值：X，地址：0x7ffe3b1a5c3b

int *p;      // p 是一个指针变量，它可以存放一个 int 类型变量的地址

#include <stdio.h>

int main(void)
{
    int a = 10;
    int *p = &a;          // p 保存了 a 的地址，我们说"p 指向 a"

    printf("a  的值：%d\n", a);
    printf("&a 的值：%p\n", (void *)&a);
    printf("p  的值：%p\n", (void *)p);
    printf("*p 的值：%d\n", *p);

    *p = 20;              // 通过 p 修改它所指向的变量，也就是修改 a
    printf("修改后 a 的值：%d\n", a);
    return 0;
}

a  的值：10
&a 的值：0x7ffc8a2e4b5c
p  的值：0x7ffc8a2e4b5c
*p 的值：10
修改后 a 的值：20

      变量 a（地址 0x...4b5c）            变量 p
     +------------------+          +------------------+
     |        10        |  ◀────── |  0x7ffc8a2e4b5c  |
     +------------------+          +------------------+

if (p != NULL) {
    printf("%d\n", *p);
}

int *p;      // 野指针：p 里存的是一个随机地址
*p = 10;     // 危险！向一个未知的地址写入数据

int *bad_function(void)
{
    int x = 10;
    return &x;      // 错误！函数返回后 x 就被销毁了，返回的地址已经失效
}

#include <stdio.h>

void swap(int *a, int *b)
{
    int temp = *a;
    *a = *b;
    *b = temp;
}

int main(void)
{
    int x = 1, y = 2;
    swap(&x, &y);
    printf("x = %d, y = %d\n", x, y);
    return 0;
}

x = 2, y = 1

    main 的栈帧                         swap 的栈帧
  +-------+-------+                +---------+---------+
  | x = 1 | y = 2 |                | a = &x  | b = &y  |
  +-------+-------+                +---------+---------+
      ▲       ▲                         │         │
      │       └─────────────────────────┼─────────┘
      └─────────────────────────────────┘
       swap 通过 *a、*b 直接修改了 main 中的 x 和 y

#include <stdio.h>

// 计算 a 除以 b 的商和余数
void div_mod(int a, int b, int *quotient, int *remainder)
{
    *quotient = a / b;
    *remainder = a % b;
}

int main(void)
{
    int q, r;
    div_mod(17, 5, &q, &r);
    printf("17 ÷ 5 = %d 余 %d\n", q, r);
    return 0;
}

17 ÷ 5 = 3 余 2

#include <stdio.h>

int main(void)
{
    int arr[5] = {10, 20, 30, 40, 50};
    int *p = arr;                  // 等价于 int *p = &arr[0];

    printf("p     = %p, *p       = %d\n", (void *)p, *p);
    printf("p + 1 = %p, *(p + 1) = %d\n", (void *)(p + 1), *(p + 1));
    printf("p + 2 = %p, *(p + 2) = %d\n", (void *)(p + 2), *(p + 2));

    char str[] = "abc";
    char *q = str;
    printf("q     = %p\n", (void *)q);
    printf("q + 1 = %p\n", (void *)(q + 1));

    int *last = &arr[4];
    printf("last - p = %td\n", last - p);
    return 0;
}

p     = 0x7ffd4f6c1e20, *p       = 10
p + 1 = 0x7ffd4f6c1e24, *(p + 1) = 20
p + 2 = 0x7ffd4f6c1e28, *(p + 2) = 30
q     = 0x7ffd4f6c1e1c
q + 1 = 0x7ffd4f6c1e1d
last - p = 4

arr[i]  ≡  *(arr + i)  ≡  *(p + i)  ≡  p[i]

#include <stdio.h>

int main(void)
{
    int arr[5] = {10, 20, 30, 40, 50};
    int *p = arr;

    // 四种等价的访问方式
    printf("%d %d %d %d\n", arr[2], *(arr + 2), p[2], *(p + 2));

    // 用指针遍历数组
    for (int *q = arr; q < arr + 5; q++) {
        printf("%d ", *q);
    }
    printf("\n");

    printf("sizeof(arr) = %zu\n", sizeof(arr));
    printf("sizeof(p)   = %zu\n", sizeof(p));
    return 0;
}

30 30 30 30
10 20 30 40 50
sizeof(arr) = 20
sizeof(p)   = 8

#include <stdio.h>

int main(void)
{
    char s[] = "hello";          // 字符数组：用字符串字面量的内容初始化数组，可以修改
    const char *p = "hello";     // 字符指针：指向只读的字符串字面量

    s[0] = 'H';                  // 正确：修改的是数组自己的副本
    // p[0] = 'H';               // 错误：不能修改字符串字面量
    p = "world";                 // 正确：指针可以改为指向另一个字符串
    // s = "world";              // 错误：数组名不能被赋值

    printf("%s %s\n", s, p);
    return 0;
}

Hello world

 栈上的数组 s（可以修改）               只读数据区（不能修改）
+---+---+---+---+---+----+          +---+---+---+---+---+----+
| H | e | l | l | o | \0 |          | h | e | l | l | o | \0 |   ← 字面量 "hello"
+---+---+---+---+---+----+          +---+---+---+---+---+----+
                                    +---+---+---+---+---+----+
   指针 p ─────────────────────────▶ | w | o | r | l | d | \0 |   ← 字面量 "world"
                                    +---+---+---+---+---+----+

size_t my_strlen(const char *s)
{
    const char *p = s;
    while (*p != '\0') {
        p++;
    }
    return (size_t)(p - s);      // 两个指针的距离就是字符串的长度
}

char *my_strcpy(char *dest, const char *src)
{
    char *start = dest;
    while ((*dest++ = *src++) != '\0') {
        // 空循环体：复制和移动都在条件表达式中完成了
    }
    return start;
}

int a = 1, b = 2;

const int *p1 = &a;
// *p1 = 10;       // 错误：不能通过 p1 修改数据
p1 = &b;           // 正确：p1 可以指向别处

int *const p2 = &a;
*p2 = 10;          // 正确：可以通过 p2 修改数据
// p2 = &b;        // 错误：p2 不能指向别处

#include <stdio.h>

int main(void)
{
    int a = 10;
    int *p = &a;       // p 指向 a
    int **pp = &p;     // pp 指向 p

    printf("a = %d, *p = %d, **pp = %d\n", a, *p, **pp);
    **pp = 20;         // 相当于 *p = 20，也就是 a = 20
    printf("a = %d\n", a);
    return 0;
}

a = 10, *p = 10, **pp = 10
a = 20

      pp                  p                  a
+-----------+       +-----------+       +---------+
|  &p   ●───┼─────▶ |  &a   ●───┼─────▶ |   10    |
+-----------+       +-----------+       +---------+

#include <stdio.h>

// 让调用者的指针 *pmax 指向数组中最大的元素
void point_to_max(int *arr, int n, int **pmax)
{
    *pmax = &arr[0];
    for (int i = 1; i < n; i++) {
        if (arr[i] > **pmax) {
            *pmax = &arr[i];
        }
    }
}

int main(void)
{
    int a[] = {3, 9, 4, 7};
    int *pm = NULL;
    point_to_max(a, 4, &pm);
    printf("最大值是 %d，下标为 %td\n", *pm, pm - a);
    *pm = 0;                       // 通过 pm 直接修改数组中的最大元素
    printf("修改后：%d %d %d %d\n", a[0], a[1], a[2], a[3]);
    return 0;
}

最大值是 9，下标为 1
修改后：3 0 4 7

#include <stdio.h>

int main(void)
{
    // 指针数组：每个元素都是一个指向字符串的指针
    const char *weekdays[] = {"Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"};
    for (int i = 0; i < 7; i++) {
        printf("%s ", weekdays[i]);
    }
    printf("\n");

    // 数组指针：指向二维数组中的一行
    int m[3][4] = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}};
    int (*row)[4] = m;             // m 退化为指向第 0 行的指针
    printf("row[1][2] = %d\n", row[1][2]);
    row++;                         // 移动到下一行（跨过 4 个 int）
    printf("(*row)[0] = %d\n", (*row)[0]);
    return 0;
}

Mon Tue Wed Thu Fri Sat Sun
row[1][2] = 7
(*row)[0] = 5

weekdays（指针数组）
+-------+       +---+---+---+----+
|   ●───┼──────▶| M | o | n | \0 |
+-------+       +---+---+---+----+
|   ●───┼──────▶| T | u | e | \0 |
+-------+       +---+---+---+----+
|  ...  |

m[i][j]  ≡  *(*(m + i) + j)

#include <stdio.h>

int main(int argc, char *argv[])
{
    printf("共有 %d 个命令行参数：\n", argc);
    for (int i = 0; i < argc; i++) {
        printf("argv[%d] = %s\n", i, argv[i]);
    }
    return 0;
}

$ ./args hello 123 "C language"
共有 4 个命令行参数：
argv[0] = ./args
argv[1] = hello
argv[2] = 123
argv[3] = C language

#include <stdio.h>

int add(int a, int b) { return a + b; }
int sub(int a, int b) { return a - b; }
int mul(int a, int b) { return a * b; }

int main(void)
{
    int (*op)(int, int);    // op 是一个指针，指向"接收两个 int、返回 int"的函数
    op = add;               // 函数名就代表函数的地址
    printf("add: %d\n", op(6, 3));
    op = mul;
    printf("mul: %d\n", op(6, 3));

    // 函数指针数组：根据下标选择要调用的函数
    int (*ops[])(int, int) = {add, sub, mul};
    const char *names[] = {"加", "减", "乘"};
    for (int i = 0; i < 3; i++) {
        printf("6 %s 3 = %d\n", names[i], ops[i](6, 3));
    }
    return 0;
}

add: 9
mul: 18
6 加 3 = 9
6 减 3 = 3
6 乘 3 = 18

typedef int (*BinaryOp)(int, int);   // BinaryOp 代表"指向这类函数的指针"类型
BinaryOp op = add;

void qsort(void *base, size_t count, size_t size,
           int (*compare)(const void *, const void *));

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

int compare_asc(const void *a, const void *b)
{
    int x = *(const int *)a;     // 先把 void * 转换为 int *，再解引用
    int y = *(const int *)b;
    return (x > y) - (x < y);    // x > y 时为 1，x < y 时为 -1，相等时为 0
}

int compare_desc(const void *a, const void *b)
{
    return compare_asc(b, a);    // 交换参数的顺序，就得到了降序
}

void print_array(const int *arr, int n)
{
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
}

int main(void)
{
    int a[] = {42, 7, 19, 88, 3, 56};
    int n = sizeof(a) / sizeof(a[0]);

    qsort(a, n, sizeof(a[0]), compare_asc);
    printf("升序：");
    print_array(a, n);

    qsort(a, n, sizeof(a[0]), compare_desc);
    printf("降序：");
    print_array(a, n);
    return 0;
}

升序：3 7 19 42 56 88
降序：88 56 42 19 7 3

   int arr[] = {10, 20, 30, 40};
   int *p = arr;
   printf("%d ", *p++);
   printf("%d ", *p);
   printf("%d ", (*p)++);
   printf("%d ", *p);
   printf("%d ", *++p);
   printf("%d\n", (int)(p - arr));
   printf("%d %d %d %d\n", arr[0], arr[1], arr[2], arr[3]);

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

struct Student {        // 定义一个名为 struct Student 的新类型
    int id;             // 成员：学号
    char name[20];      // 成员：姓名
    int age;            // 成员：年龄
    double score;       // 成员：成绩
};                      // 注意：末尾的分号不能少

int main(void)
{
    struct Student s1 = {1001, "张三", 19, 88.5};      // 按成员顺序初始化
    struct Student s2 = {.name = "李四", .id = 1002};  // C99 指定初始化，未指定的成员为 0

    s2.age = 20;                     // 用"."访问成员
    s2.score = 92.0;
    strcpy(s1.name, "张伟");          // 数组成员不能直接用 = 赋值

    printf("%d %s %d %.1f\n", s1.id, s1.name, s1.age, s1.score);
    printf("%d %s %d %.1f\n", s2.id, s2.name, s2.age, s2.score);

    struct Student s3 = s1;          // 结构体可以整体赋值，所有成员（包括数组）都会被复制
    s3.id = 1003;
    printf("%d %s %d %.1f\n", s3.id, s3.name, s3.age, s3.score);
    return 0;
}

1001 张伟 19 88.5
1002 李四 20 92.0
1003 张伟 19 88.5

typedef struct {
    int id;
    char name[20];
    double score;
} Student;              // Student 现在就是这个结构体类型的名字

Student s = {1001, "张三", 88.5};   // 不用再写 struct 了

#include <stdio.h>

typedef struct {
    char name[20];
    int age;
    double score;
} Student;

// 传指针 + const：高效，并且保证不修改数据
void print_student(const Student *s)
{
    printf("姓名：%s，年龄：%d，成绩：%.1f\n", s->name, s->age, s->score);
}

// 传指针：可以修改调用者的结构体
void add_bonus(Student *s, double bonus)
{
    s->score += bonus;
    if (s->score > 100) {
        s->score = 100;
    }
}

// 传值：函数拿到的是副本，修改不会影响原结构体
void try_modify(Student s)
{
    s.age = 99;
    printf("函数内修改后的年龄：%d\n", s.age);
}

int main(void)
{
    Student stu = {"王五", 18, 95.0};
    Student *p = &stu;

    printf("%s %d\n", (*p).name, p->age);
    add_bonus(&stu, 8);
    try_modify(stu);
    print_student(&stu);
    return 0;
}

王五 18
函数内修改后的年龄：99
姓名：王五，年龄：18，成绩：100.0

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

typedef struct {
    char name[20];
    int score;
} Player;

int compare_by_score_desc(const void *a, const void *b)
{
    const Player *pa = a;      // void * 可以直接赋给其他类型的指针
    const Player *pb = b;
    return (pb->score > pa->score) - (pb->score < pa->score);
}

int main(void)
{
    Player players[] = {
        {"Alice", 820},
        {"Bob", 950},
        {"Carol", 760},
        {"David", 910},
        {"Eve", 880}
    };
    int n = sizeof(players) / sizeof(players[0]);

    qsort(players, n, sizeof(Player), compare_by_score_desc);

    printf("排行榜：\n");
    for (int i = 0; i < n; i++) {
        printf("%d. %-6s %d\n", i + 1, players[i].name, players[i].score);
    }
    return 0;
}

排行榜：
1. Bob    950
2. David  910
3. Eve    880
4. Alice  820
5. Carol  760

typedef struct {
    int year;
    int month;
    int day;
} Date;

typedef struct {
    char name[20];
    Date birthday;          // 成员是另一个结构体
} Person;

Person p = {"赵六", {2005, 3, 15}};
printf("%s 生于 %d 年\n", p.name, p.birthday.year);   // 逐层用 . 访问

#include <stdio.h>
#include <stddef.h>

struct A {
    char c1;
    int i;
    char c2;
};

struct B {
    char c1;
    char c2;
    int i;
};

int main(void)
{
    printf("sizeof(struct A) = %zu\n", sizeof(struct A));
    printf("sizeof(struct B) = %zu\n", sizeof(struct B));
    printf("A 中各成员的偏移量：c1 = %zu, i = %zu, c2 = %zu\n",
           offsetof(struct A, c1), offsetof(struct A, i), offsetof(struct A, c2));
    return 0;
}

sizeof(struct A) = 12
sizeof(struct B) = 8
A 中各成员的偏移量：c1 = 0, i = 4, c2 = 8

offset:  0    1    2    3    4    5    6    7    8    9   10   11
       +----+----+----+----+----+----+----+----+----+----+----+----+
       | c1 | .. | .. | .. | i  | i  | i  | i  | c2 | .. | .. | .. |
       +----+----+----+----+----+----+----+----+----+----+----+----+

#include <stdio.h>

enum Weekday { MON = 1, TUE, WED, THU, FRI, SAT, SUN };   // TUE 为 2，之后依次加 1

int main(void)
{
    enum Weekday today = SAT;
    printf("今天是星期 %d\n", today);

    switch (today) {
    case SAT:
    case SUN:
        printf("周末愉快！\n");
        break;
    default:
        printf("工作日，加油！\n");
        break;
    }
    return 0;
}

今天是星期 6
周末愉快！

#include <stdio.h>

union Data {
    int i;
    float f;
    char str[8];
};

int main(void)
{
    union Data d;
    printf("sizeof(union Data) = %zu\n", sizeof(d));

    d.i = 42;
    printf("d.i = %d\n", d.i);
    d.f = 3.14f;                   // 写入 f 会覆盖 i 所在的内存
    printf("d.f = %.2f\n", d.f);
    printf("d.i = %d（已被覆盖）\n", d.i);
    return 0;
}

sizeof(union Data) = 8
d.i = 42
d.f = 3.14
d.i = 1078523331（已被覆盖）

#include <stdio.h>

typedef enum { SHAPE_CIRCLE, SHAPE_RECT } ShapeType;

typedef struct {
    ShapeType type;                       // 标签：记录这是哪种图形
    union {
        struct { double radius; } circle;
        struct { double width, height; } rect;
    } data;
} Shape;

double area(const Shape *s)
{
    switch (s->type) {
    case SHAPE_CIRCLE:
        return 3.14159265358979 * s->data.circle.radius * s->data.circle.radius;
    case SHAPE_RECT:
        return s->data.rect.width * s->data.rect.height;
    }
    return 0.0;
}

int main(void)
{
    Shape shapes[2];
    shapes[0].type = SHAPE_CIRCLE;
    shapes[0].data.circle.radius = 1.0;
    shapes[1].type = SHAPE_RECT;
    shapes[1].data.rect.width = 3.0;
    shapes[1].data.rect.height = 4.0;

    for (int i = 0; i < 2; i++) {
        printf("图形 %d 的面积：%.2f\n", i + 1, area(&shapes[i]));
    }
    return 0;
}

图形 1 的面积：3.14
图形 2 的面积：12.00

struct Flags {
    unsigned int is_read  : 1;   // 只占 1 位，取值 0 或 1
    unsigned int is_write : 1;
    unsigned int level    : 4;   // 占 4 位，取值 0~15
};

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

typedef enum { SPADE, HEART, CLUB, DIAMOND } Suit;   // 黑桃、红心、梅花、方块

typedef struct {
    Suit suit;
    int rank;          // 1~13，分别代表 A、2~10、J、Q、K
} Card;

const char *suit_name(Suit s)
{
    switch (s) {
    case SPADE:   return "黑桃";
    case HEART:   return "红心";
    case CLUB:    return "梅花";
    case DIAMOND: return "方块";
    }
    return "?";
}

void print_card(Card c)
{
    const char *ranks[] = {"", "A", "2", "3", "4", "5", "6", "7",
                           "8", "9", "10", "J", "Q", "K"};
    printf("%s%s ", suit_name(c.suit), ranks[c.rank]);
}

int main(void)
{
    Card deck[52];
    int k = 0;
    for (int s = SPADE; s <= DIAMOND; s++) {
        for (int r = 1; r <= 13; r++) {
            deck[k].suit = (Suit)s;
            deck[k].rank = r;
            k++;
        }
    }

    // Fisher-Yates 洗牌：从后往前，让每张牌与它前面（含它自己）的随机一张交换
    srand((unsigned int)time(NULL));
    for (int i = 51; i > 0; i--) {
        int j = rand() % (i + 1);
        Card temp = deck[i];
        deck[i] = deck[j];
        deck[j] = temp;
    }

    printf("你的五张牌：");
    for (int i = 0; i < 5; i++) {
        print_card(deck[i]);
    }
    printf("\n");
    return 0;
}

你的五张牌：红心7 黑桃K 方块A 梅花10 红心Q

   struct X { char a; double b; int c; };
   struct Y { double b; int c; char a; };

高地址 +--------------------------+
       |        栈（stack）        |  局部变量、函数参数；自动分配和释放；空间较小
       |            ↓             |
       |                          |
       |            ↑             |
       |        堆（heap）         |  malloc 等函数申请的内存；手动申请和释放；空间大
       +--------------------------+
       |      全局 / 静态数据区      |  全局变量、static 变量；程序运行期间一直存在
       +--------------------------+
       |        只读数据区          |  字符串字面量等常量
       +--------------------------+
       |          代码区           |  程序的机器指令
低地址 +--------------------------+

void *malloc(size_t size);   // 申请 size 个字节，成功时返回首地址，失败时返回 NULL
void free(void *ptr);        // 释放 ptr 所指向的、之前由 malloc 等函数申请的内存

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

int main(void)
{
    int n;
    printf("要输入几个整数？");
    if (scanf("%d", &n) != 1 || n <= 0) {
        printf("输入无效\n");
        return 1;
    }

    int *arr = malloc(n * sizeof(int));   // 申请能存放 n 个 int 的内存
    if (arr == NULL) {                    // 申请可能失败，必须检查
        printf("内存不足！\n");
        return 1;
    }

    printf("请输入 %d 个整数：", n);
    for (int i = 0; i < n; i++) {
        scanf("%d", &arr[i]);             // 像使用普通数组一样使用它
    }

    printf("逆序输出：");
    for (int i = n - 1; i >= 0; i--) {
        printf("%d ", arr[i]);
    }
    printf("\n");

    free(arr);                            // 用完后释放
    arr = NULL;                           // 释放后置为 NULL，防止误用
    return 0;
}

要输入几个整数？5
请输入 5 个整数：1 2 3 4 5
逆序输出：5 4 3 2 1

int *scores = calloc(100, sizeof *scores);   // 100 个 int，全部为 0

p = realloc(p, new_size);          // 危险！

int *temp = realloc(p, new_size);
if (temp == NULL) {
    // 扩容失败，p 仍然有效，可以继续使用或释放
    free(p);
    return 1;
}
p = temp;                           // 成功后再更新 p

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

typedef struct {
    int *data;          // 指向堆上存放元素的空间
    size_t size;        // 当前的元素个数
    size_t capacity;    // 当前的容量（最多能放多少个元素）
} IntVector;

void vec_init(IntVector *v)
{
    v->data = NULL;
    v->size = 0;
    v->capacity = 0;
}

// 在末尾添加一个元素；成功返回 true，内存不足时返回 false
bool vec_push(IntVector *v, int value)
{
    if (v->size == v->capacity) {                     // 空间已满，需要扩容
        size_t new_cap = (v->capacity == 0) ? 4 : v->capacity * 2;
        int *new_data = realloc(v->data, new_cap * sizeof *new_data);
        if (new_data == NULL) {
            return false;                             // 扩容失败，原有数据仍然完好
        }
        v->data = new_data;
        v->capacity = new_cap;
        printf("  [扩容] 容量变为 %zu\n", new_cap);
    }
    v->data[v->size] = value;
    v->size++;
    return true;
}

void vec_free(IntVector *v)
{
    free(v->data);
    vec_init(v);                                      // 恢复为空的状态
}

int main(void)
{
    IntVector v;
    vec_init(&v);

    printf("请输入若干个整数，以 0 结束：\n");
    int x;
    while (scanf("%d", &x) == 1 && x != 0) {
        if (!vec_push(&v, x)) {
            printf("内存不足！\n");
            break;
        }
    }

    long long sum = 0;
    for (size_t i = 0; i < v.size; i++) {
        sum += v.data[i];
    }
    printf("共 %zu 个数，总和为 %lld\n", v.size, sum);
    if (v.size > 0) {
        printf("平均值为 %.2f\n", (double)sum / v.size);
    }

    vec_free(&v);
    return 0;
}

请输入若干个整数，以 0 结束：
3 8 1 9 4 7 2 6 5 10 0
  [扩容] 容量变为 4
  [扩容] 容量变为 8
  [扩容] 容量变为 16
共 10 个数，总和为 55
平均值为 5.50

// 方式一：通过返回值交出新申请的内存
int *create_array(size_t n, int init_value)
{
    int *arr = malloc(n * sizeof *arr);
    if (arr != NULL) {
        for (size_t i = 0; i < n; i++) {
            arr[i] = init_value;
        }
    }
    return arr;          // 调用者负责检查是否为 NULL，并在用完后 free
}

// 方式二：通过二级指针参数交出新申请的内存，返回值用来表示成功与否
bool create_zero_array(size_t n, int **out)
{
    *out = calloc(n, sizeof **out);
    return *out != NULL;
}

void wrong_alloc(int *p, size_t n)
{
    p = malloc(n * sizeof *p);   // 只修改了形参 p，调用者的指针不受任何影响
}                                // 而且这块内存的地址丢失了，造成内存泄漏

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

int main(void)
{
    int rows = 3, cols = 4;
    int *m = malloc((size_t)rows * cols * sizeof *m);
    if (m == NULL) {
        return 1;
    }

    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            m[i * cols + j] = i * 10 + j;    // 第 i 行第 j 列
        }
    }
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            printf("%4d", m[i * cols + j]);
        }
        printf("\n");
    }

    free(m);
    return 0;
}

   0   1   2   3
  10  11  12  13
  20  21  22  23

#include <stdlib.h>

int main(void)
{
    int *arr = malloc(5 * sizeof *arr);
    if (arr == NULL) {
        return 1;
    }
    for (int i = 0; i <= 5; i++) {    // 错误：i 会取到 5，越界了
        arr[i] = i;
    }
    free(arr);
    return 0;
}

$ gcc -g -fsanitize=address overflow.c -o overflow
$ ./overflow
==12345==ERROR: AddressSanitizer: heap-buffer-overflow on address 0x503000000024 ...
WRITE of size 4 at 0x503000000024 thread T0
    #0 0x... in main overflow.c:10
    ...
0x503000000024 is located 0 bytes after 20-byte region [0x503000000010,0x503000000024)
allocated by thread T0 here:
    #0 0x... in malloc ...
    #1 0x... in main overflow.c:5

$ valgrind --leak-check=full ./program

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

   char *make_greeting(const char *name)
   {
       char *buf = malloc(strlen("Hello, ") + strlen(name));
       strcpy(buf, "Hello, ");
       strcat(buf, name);
       return buf;
   }

   int main(void)
   {
       char *s = make_greeting("Tom");
       printf("%s\n", s);
       free(s);
       printf("%s\n", s);

       int *nums = malloc(10 * sizeof(int));
       nums = malloc(20 * sizeof(int));
       free(nums);
       free(nums);
       return 0;
   }

 head
  │
  ▼
+----+---+     +----+---+     +----+------+
| 10 | ●─┼───▶ | 20 | ●─┼───▶ | 30 | NULL |
+----+---+     +----+---+     +----+------+
 数据  指针

typedef struct Node {
    int data;             // 数据域
    struct Node *next;    // 指针域：指向下一个节点
} Node;

Node *head = NULL;

for (const Node *cur = head; cur != NULL; cur = cur->next) {
    printf("%d -> ", cur->data);
}

插入前：   head ──▶ [10|●]──▶ [20|●]──▶ NULL

① node->next = head;     让新节点指向原来的第一个节点

           node ──▶ [5|●]──┐
                           ▼
           head ──▶ [10|●]──▶ [20|●]──▶ NULL

② head = node;           让头指针指向新节点

           head ──▶ [5|●]──▶ [10|●]──▶ [20|●]──▶ NULL

node->next = pos->next;   // ① 新节点先指向 pos 的下一个节点
pos->next = node;         // ② pos 再指向新节点

删除 20：prev 指向 10，cur 指向 20

   head ──▶ [10|●]──▶ [20|●]──▶ [30|●]──▶ NULL
             prev       cur

prev->next = cur->next;  free(cur);

   head ──▶ [10|●]──────────────▶ [30|●]──▶ NULL

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

typedef struct Node {
    int data;
    struct Node *next;
} Node;

// 创建一个新节点
Node *create_node(int value)
{
    Node *node = malloc(sizeof *node);
    if (node == NULL) {
        fprintf(stderr, "内存不足\n");
        exit(EXIT_FAILURE);             // 内存耗尽，无法继续，直接结束程序
    }
    node->data = value;
    node->next = NULL;
    return node;
}

// 头插法
void push_front(Node **head, int value)
{
    Node *node = create_node(value);
    node->next = *head;
    *head = node;
}

// 尾插法
void push_back(Node **head, int value)
{
    Node *node = create_node(value);
    if (*head == NULL) {                // 空链表：新节点就是第一个节点
        *head = node;
        return;
    }
    Node *cur = *head;
    while (cur->next != NULL) {         // 找到最后一个节点
        cur = cur->next;
    }
    cur->next = node;
}

// 在节点 pos 之后插入新节点
void insert_after(Node *pos, int value)
{
    Node *node = create_node(value);
    node->next = pos->next;
    pos->next = node;
}

// 查找第一个值为 value 的节点，找不到返回 NULL
Node *find(Node *head, int value)
{
    for (Node *cur = head; cur != NULL; cur = cur->next) {
        if (cur->data == value) {
            return cur;
        }
    }
    return NULL;
}

// 删除第一个值为 value 的节点，成功返回 true
bool remove_value(Node **head, int value)
{
    Node *prev = NULL;
    Node *cur = *head;
    while (cur != NULL && cur->data != value) {
        prev = cur;
        cur = cur->next;
    }
    if (cur == NULL) {                  // 没有找到
        return false;
    }
    if (prev == NULL) {                 // 要删除的是第一个节点
        *head = cur->next;
    } else {
        prev->next = cur->next;
    }
    free(cur);
    return true;
}

// 输出链表
void print_list(const Node *head)
{
    for (const Node *cur = head; cur != NULL; cur = cur->next) {
        printf("%d -> ", cur->data);
    }
    printf("NULL\n");
}

// 释放整个链表
void free_list(Node **head)
{
    Node *cur = *head;
    while (cur != NULL) {
        Node *next = cur->next;         // 先保存下一个节点的地址
        free(cur);                      // 再释放当前节点
        cur = next;
    }
    *head = NULL;
}

int main(void)
{
    Node *head = NULL;

    for (int i = 1; i <= 5; i++) {
        push_back(&head, i * 10);
    }
    printf("尾插 10~50：");
    print_list(head);

    push_front(&head, 5);
    printf("头插 5：    ");
    print_list(head);

    Node *p = find(head, 30);
    if (p != NULL) {
        insert_after(p, 35);
    }
    printf("30 后插 35：");
    print_list(head);

    remove_value(&head, 5);
    remove_value(&head, 50);
    printf("删除 5、50：");
    print_list(head);

    free_list(&head);
    printf("释放后：    ");
    print_list(head);
    return 0;
}

尾插 10~50：10 -> 20 -> 30 -> 40 -> 50 -> NULL
头插 5：    5 -> 10 -> 20 -> 30 -> 40 -> 50 -> NULL
30 后插 35：5 -> 10 -> 20 -> 30 -> 35 -> 40 -> 50 -> NULL
删除 5、50：10 -> 20 -> 30 -> 35 -> 40 -> NULL
释放后：    NULL

  NULL ◀──[● | 10 | ●]◀──▶[● | 20 | ●]◀──▶[● | 30 | ●]──▶ NULL

#include <stdio.h>

int main(void)
{
    FILE *fp = fopen("hello.txt", "w");      // 以写入方式打开，文件不存在就创建
    if (fp == NULL) {
        perror("打开文件失败");
        return 1;
    }
    fprintf(fp, "Hello, File!\n");
    fprintf(fp, "今天是 %d 年 %d 月 %d 日\n", 2026, 9, 26);
    fclose(fp);                               // 关闭文件

    fp = fopen("hello.txt", "r");             // 以读取方式重新打开
    if (fp == NULL) {
        perror("打开文件失败");
        return 1;
    }
    char line[100];
    while (fgets(line, sizeof(line), fp) != NULL) {
        printf("读到：%s", line);
    }
    fclose(fp);
    return 0;
}

读到：Hello, File!
读到：今天是 2026 年 9 月 26 日

打开文件失败: No such file or directory

#include <stdio.h>

int main(void)
{
    FILE *fp = fopen("hello.txt", "r");
    if (fp == NULL) {
        perror("hello.txt");
        return 1;
    }

    int ch;                             // 必须用 int，才能与 EOF 正确比较
    long bytes = 0, lines = 0;
    while ((ch = fgetc(fp)) != EOF) {
        bytes++;
        if (ch == '\n') {
            lines++;
        }
    }
    fclose(fp);

    printf("共 %ld 个字节，%ld 行\n", bytes, lines);
    return 0;
}

共 45 个字节，2 行

char line[256];
while (fgets(line, sizeof(line), fp) != NULL) {
    // 处理这一行
}

#include <stdio.h>

typedef struct {
    char name[20];
    int age;
    double score;
} Student;

int main(void)
{
    Student students[] = {
        {"张三", 19, 88.5},
        {"李四", 20, 92.0},
        {"王五", 18, 76.5}
    };
    int n = sizeof(students) / sizeof(students[0]);

    FILE *fp = fopen("students.txt", "w");
    if (fp == NULL) {
        perror("students.txt");
        return 1;
    }
    for (int i = 0; i < n; i++) {
        fprintf(fp, "%s %d %.1f\n", students[i].name, students[i].age, students[i].score);
    }
    fclose(fp);

    fp = fopen("students.txt", "r");
    if (fp == NULL) {
        perror("students.txt");
        return 1;
    }
    Student s;
    int count = 0;
    while (fscanf(fp, "%19s %d %lf", s.name, &s.age, &s.score) == 3) {
        count++;
        printf("第 %d 条：%s，%d 岁，%.1f 分\n", count, s.name, s.age, s.score);
    }
    fclose(fp);
    return 0;
}

第 1 条：张三，19 岁，88.5 分
第 2 条：李四，20 岁，92.0 分
第 3 条：王五，18 岁，76.5 分

张三 19 88.5
李四 20 92.0
王五 18 76.5

size_t fwrite(const void *ptr, size_t size, size_t count, FILE *fp);
size_t fread(void *ptr, size_t size, size_t count, FILE *fp);

#include <stdio.h>

typedef struct {
    char name[20];
    int age;
    double score;
} Student;

int main(void)
{
    Student out[3] = {{"张三", 19, 88.5}, {"李四", 20, 92.0}, {"王五", 18, 76.5}};

    FILE *fp = fopen("students.dat", "wb");
    if (fp == NULL) {
        perror("students.dat");
        return 1;
    }
    size_t written = fwrite(out, sizeof(Student), 3, fp);   // 一次写入整个数组
    fclose(fp);
    printf("写入了 %zu 条记录，每条 %zu 字节\n", written, sizeof(Student));

    Student in[3];
    fp = fopen("students.dat", "rb");
    if (fp == NULL) {
        perror("students.dat");
        return 1;
    }
    size_t count = fread(in, sizeof(Student), 3, fp);
    fclose(fp);

    for (size_t i = 0; i < count; i++) {
        printf("%s %d %.1f\n", in[i].name, in[i].age, in[i].score);
    }
    return 0;
}

写入了 3 条记录，每条 32 字节
张三 19 88.5
李四 20 92.0
王五 18 76.5

FILE *fp = fopen("students.dat", "rb");
if (fp != NULL) {
    fseek(fp, 0, SEEK_END);          // 移动到文件末尾
    long size = ftell(fp);           // 此时的位置就是文件大小
    printf("文件大小：%ld 字节\n", size);   // 输出：文件大小：96 字节
    fclose(fp);
}

while (!feof(fp)) {                      // 错误的写法！
    fgets(line, sizeof(line), fp);
    printf("%s", line);
}

#include <stdio.h>

int main(int argc, char *argv[])
{
    if (argc != 3) {
        fprintf(stderr, "用法：%s 源文件 目标文件\n", argv[0]);
        return 1;
    }

    FILE *src = fopen(argv[1], "rb");
    if (src == NULL) {
        perror(argv[1]);
        return 1;
    }
    FILE *dst = fopen(argv[2], "wb");
    if (dst == NULL) {
        perror(argv[2]);
        fclose(src);                      // 别忘了关闭已经打开的文件
        return 1;
    }

    char buffer[4096];                    // 每次最多读写 4 KB
    size_t n;
    long long total = 0;
    while ((n = fread(buffer, 1, sizeof(buffer), src)) > 0) {
        if (fwrite(buffer, 1, n, dst) != n) {
            perror("写入失败");
            fclose(src);
            fclose(dst);
            return 1;
        }
        total += (long long)n;
    }
    if (ferror(src)) {
        perror("读取失败");
        fclose(src);
        fclose(dst);
        return 1;
    }

    fclose(src);
    if (fclose(dst) != 0) {               // 部分数据可能在关闭时才真正写入磁盘，所以也要检查
        perror(argv[2]);
        return 1;
    }
    printf("复制完成，共 %lld 字节\n", total);
    return 0;
}

$ gcc -Wall -Wextra mycp.c -o mycp
$ ./mycp students.dat backup.dat
复制完成，共 96 字节
$ ./mycp nothing.txt a.txt
nothing.txt: No such file or directory

#define MAX_STUDENTS 100
#define PI 3.14159265358979

#include <stdio.h>

#define SQUARE_BAD(x) x * x
#define SQUARE(x) ((x) * (x))
#define DOUBLE_BAD(x) (x) + (x)
#define DOUBLE(x) ((x) + (x))

int main(void)
{
    printf("SQUARE_BAD(1 + 2)  = %d\n", SQUARE_BAD(1 + 2));
    printf("SQUARE(1 + 2)      = %d\n", SQUARE(1 + 2));
    printf("10 * DOUBLE_BAD(3) = %d\n", 10 * DOUBLE_BAD(3));
    printf("10 * DOUBLE(3)     = %d\n", 10 * DOUBLE(3));
    return 0;
}

SQUARE_BAD(1 + 2)  = 5
SQUARE(1 + 2)      = 9
10 * DOUBLE_BAD(3) = 33
10 * DOUBLE(3)     = 60

static inline int square(int x)
{
    return x * x;
}

#include <stdio.h>

#define PRINT_INT(x) printf(#x " = %d\n", x)          // #x 把传入的实参原样变成字符串
#define SWAP_INT(a, b) do { int t_ = (a); (a) = (b); (b) = t_; } while (0)

int main(void)
{
    int width = 3, height = 5;
    PRINT_INT(width * height);
    SWAP_INT(width, height);
    PRINT_INT(width);
    PRINT_INT(height);
    return 0;
}

width * height = 15
width = 5
height = 3

#include <stdio.h>

#ifdef DEBUG
    #define LOG(msg) fprintf(stderr, "[DEBUG] %s:%d: %s\n", __FILE__, __LINE__, msg)
#else
    #define LOG(msg) ((void)0)
#endif

int main(void)
{
    LOG("程序开始");
    int sum = 0;
    for (int i = 1; i <= 10; i++) {
        sum += i;
    }
    LOG("计算完成");
    printf("sum = %d\n", sum);
    return 0;
}

$ gcc log_demo.c -o log_demo
$ ./log_demo
sum = 55

$ gcc -DDEBUG log_demo.c -o log_demo
$ ./log_demo
[DEBUG] log_demo.c:11: 程序开始
[DEBUG] log_demo.c:16: 计算完成
sum = 55

#ifdef _WIN32
    #define CLEAR_SCREEN "cls"
#else
    #define CLEAR_SCREEN "clear"
#endif

#ifndef STATS_H
#define STATS_H

double stats_mean(const double *data, int n);
double stats_max(const double *data, int n);
double stats_min(const double *data, int n);
int stats_call_count(void);

#endif

#include "stats.h"

static int call_count = 0;       // static 全局变量：只在本文件中可见

// static 函数：只供本文件内部使用，其他文件无法调用
static double sum_of(const double *data, int n)
{
    double sum = 0.0;
    for (int i = 0; i < n; i++) {
        sum += data[i];
    }
    return sum;
}

double stats_mean(const double *data, int n)
{
    call_count++;
    return sum_of(data, n) / n;
}

double stats_max(const double *data, int n)
{
    call_count++;
    double m = data[0];
    for (int i = 1; i < n; i++) {
        if (data[i] > m) {
            m = data[i];
        }
    }
    return m;
}

double stats_min(const double *data, int n)
{
    call_count++;
    double m = data[0];
    for (int i = 1; i < n; i++) {
        if (data[i] < m) {
            m = data[i];
        }
    }
    return m;
}

int stats_call_count(void)
{
    return call_count;
}

#include <stdio.h>
#include "stats.h"

int main(void)
{
    double scores[] = {88.5, 92.0, 76.5, 95.0, 81.0};
    int n = sizeof(scores) / sizeof(scores[0]);

    printf("平均分：%.2f\n", stats_mean(scores, n));
    printf("最高分：%.1f\n", stats_max(scores, n));
    printf("最低分：%.1f\n", stats_min(scores, n));
    printf("统计函数共被调用 %d 次\n", stats_call_count());
    return 0;
}

$ gcc -Wall -Wextra main.c stats.c -o stats_demo
$ ./stats_demo
平均分：86.60
最高分：95.0
最低分：76.5
统计函数共被调用 3 次

// config.h
extern int g_verbose;       // 声明：告诉编译器"这个变量在别处定义"，不分配内存

// config.c
#include "config.h"
int g_verbose = 0;          // 定义：真正分配内存，整个程序中只能出现一次

$ gcc -Wall -Wextra -c main.c      # 编译 main.c，生成目标文件 main.o
$ gcc -Wall -Wextra -c stats.c     # 编译 stats.c，生成目标文件 stats.o
$ gcc main.o stats.o -o stats_demo # 把两个目标文件链接成可执行程序

CC = gcc
CFLAGS = -Wall -Wextra -std=c11 -g

stats_demo: main.o stats.o
	$(CC) $(CFLAGS) -o stats_demo main.o stats.o

main.o: main.c stats.h
	$(CC) $(CFLAGS) -c main.c

stats.o: stats.c stats.h
	$(CC) $(CFLAGS) -c stats.c

clean:
	rm -f stats_demo *.o

目标: 依赖文件
<Tab>生成目标的命令

#include <stdio.h>

void print_bits8(unsigned int x)          // 输出 x 的低 8 位
{
    for (int i = 7; i >= 0; i--) {
        putchar(((x >> i) & 1u) ? '1' : '0');
    }
}

void show(unsigned int x, const char *label)
{
    print_bits8(x);
    printf("  %3u  %s\n", x & 0xFFu, label);
}

int main(void)
{
    unsigned int a = 12, b = 10;
    show(a, "a");
    show(b, "b");
    show(a & b, "a & b（按位与）");
    show(a | b, "a | b（按位或）");
    show(a ^ b, "a ^ b（按位异或）");
    show(~a, "~a（按位取反，只看低 8 位）");
    show(a << 2, "a << 2（左移 2 位）");
    show(a >> 2, "a >> 2（右移 2 位）");
    return 0;
}

00001100   12  a
00001010   10  b
00001000    8  a & b（按位与）
00001110   14  a | b（按位或）
00000110    6  a ^ b（按位异或）
11110011  243  ~a（按位取反，只看低 8 位）
00110000   48  a << 2（左移 2 位）
00000011    3  a >> 2（右移 2 位）

#include <stdio.h>
#include <stdbool.h>

void print_bits8(unsigned int x)
{
    for (int i = 7; i >= 0; i--) {
        putchar(((x >> i) & 1u) ? '1' : '0');
    }
}

void show(unsigned int x, const char *label)
{
    print_bits8(x);
    printf("  %3u  %s\n", x & 0xFFu, label);
}

bool is_power_of_two(unsigned int n)
{
    return n != 0 && (n & (n - 1)) == 0;
}

int main(void)
{
    unsigned int n = 44;
    show(n, "n 本身");
    show(n | (1u << 0), "将第 0 位置 1：n | (1u << 0)");
    show(n & ~(1u << 5), "将第 5 位清 0：n & ~(1u << 5)");
    show(n ^ (1u << 7), "将第 7 位翻转：n ^ (1u << 7)");
    show(n & (n - 1), "去掉最低位的 1：n & (n - 1)");
    show(n & (~n + 1), "只保留最低位的 1：n & (~n + 1)");
    printf("n 的第 3 位是 %u\n", (n >> 3) & 1u);
    printf("44 是 2 的幂吗？%s\n", is_power_of_two(44) ? "是" : "否");
    printf("64 是 2 的幂吗？%s\n", is_power_of_two(64) ? "是" : "否");
    return 0;
}

00101100   44  n 本身
00101101   45  将第 0 位置 1：n | (1u << 0)
00001100   12  将第 5 位清 0：n & ~(1u << 5)
10101100  172  将第 7 位翻转：n ^ (1u << 7)
00101000   40  去掉最低位的 1：n & (n - 1)
00000100    4  只保留最低位的 1：n & (~n + 1)
n 的第 3 位是 1
44 是 2 的幂吗？否
64 是 2 的幂吗？是

#include <stdio.h>

#define PERM_READ  (1u << 2)    // 100：读
#define PERM_WRITE (1u << 1)    // 010：写
#define PERM_EXEC  (1u << 0)    // 001：执行

void print_perm(unsigned int perm)
{
    printf("%c%c%c\n",
           (perm & PERM_READ)  ? 'r' : '-',
           (perm & PERM_WRITE) ? 'w' : '-',
           (perm & PERM_EXEC)  ? 'x' : '-');
}

int main(void)
{
    unsigned int perm = PERM_READ | PERM_WRITE;   // 同时拥有读、写权限
    print_perm(perm);

    perm |= PERM_EXEC;                            // 添加执行权限
    print_perm(perm);

    perm &= ~PERM_WRITE;                          // 移除写权限
    print_perm(perm);

    if (perm & PERM_READ) {                       // 检查是否有读权限
        printf("拥有读权限\n");
    }
    return 0;
}

rw-
rwx
r-x
拥有读权限

int find_single(const int *arr, int n)
{
    int result = 0;
    for (int i = 0; i < n; i++) {
        result ^= arr[i];      // 成对的数异或后相互抵消为 0
    }
    return result;             // 对于 {4, 1, 2, 1, 2}，结果为 4
}

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

int main(void)
{
    int32_t a = -123456;
    uint8_t b = 255;
    uint64_t c = UINT64_MAX;
    printf("a = %" PRId32 "\n", a);
    printf("b = %" PRIu8 "\n", b);
    printf("c = %" PRIu64 "\n", c);
    return 0;
}

a = -123456
b = 255
c = 18446744073709551615

                  地址：  低  ──────────────▶  高
大端序（Big-Endian）：    12    34    56    78     高位字节存放在低地址
小端序（Little-Endian）： 78    56    34    12     低位字节存放在低地址

#include <stdio.h>

int main(void)
{
    unsigned int x = 0x12345678;
    unsigned char *p = (unsigned char *)&x;    // 用字节指针逐个查看 x 的每个字节

    printf("x = 0x%X\n", x);
    for (size_t i = 0; i < sizeof(x); i++) {
        printf("第 %zu 个字节：0x%02X\n", i, p[i]);
    }
    printf("这台电脑是%s\n", (p[0] == 0x78) ? "小端序" : "大端序");
    return 0;
}

x = 0x12345678
第 0 个字节：0x78
第 1 个字节：0x56
第 2 个字节：0x34
第 3 个字节：0x12
这台电脑是小端序

 31  30        23 22                                    0
+---+------------+---------------------------------------+
| S |  指数（8位） |              尾数（23位）                |
+---+------------+---------------------------------------+

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

void print_field(uint32_t value, int bits)
{
    for (int i = bits - 1; i >= 0; i--) {
        putchar(((value >> i) & 1u) ? '1' : '0');
    }
}

void print_float_bits(float f)
{
    uint32_t bits;
    memcpy(&bits, &f, sizeof bits);      // 把 float 的 4 个字节原样复制到整数中

    printf("%-6g 符号 ", f);
    print_field(bits >> 31, 1);
    printf(" | 指数 ");
    print_field((bits >> 23) & 0xFFu, 8);
    printf(" | 尾数 ");
    print_field(bits & 0x7FFFFFu, 23);
    printf("\n");
}

int main(void)
{
    print_float_bits(5.75f);
    print_float_bits(-1.0f);
    print_float_bits(0.1f);
    return 0;
}

5.75   符号 0 | 指数 10000001 | 尾数 01110000000000000000000
-1     符号 1 | 指数 01111111 | 尾数 00000000000000000000000
0.1    符号 0 | 指数 01111011 | 尾数 10011001100110011001101

#include <stdio.h>

int square(int x)
{
    int result = x * x;
}

int main(void)
{
    int n;
    double avg = 3.5;
    unsigned int count = 10;
    int unused = 0;

    if (n = 5) {
        printf("%d\n", avg);
    }
    for (int i = 0; i < count; i++) {
    }
    printf("%d\n", square(3));
    return 0;
}

warn.c: In function 'square':
warn.c:5:9: warning: unused variable 'result' [-Wunused-variable]
warn.c: In function 'main':
warn.c:15:9: warning: suggest parentheses around assignment used as truth value [-Wparentheses]
warn.c:16:18: warning: format '%d' expects argument of type 'int', but argument 2 has type 'double' [-Wformat=]
warn.c:18:23: warning: comparison of integer expressions of different signedness: 'int' and 'unsigned int' [-Wsign-compare]
warn.c:13:9: warning: unused variable 'unused' [-Wunused-variable]
warn.c: In function 'square':
warn.c:6:1: warning: control reaches end of non-void function [-Wreturn-type]

fprintf(stderr, "[调试] i = %d, sum = %d\n", i, sum);

#include <stdio.h>

long long factorial(int n)
{
    long long result = 0;
    for (int i = 1; i <= n; i++) {
        result *= i;
    }
    return result;
}

int main(void)
{
    int n = 5;
    long long f = factorial(n);
    printf("%d! = %lld\n", n, f);
    return 0;
}

5! = 0

$ gcc -g -O0 fact.c -o fact
$ gdb ./fact
(gdb) break factorial
Breakpoint 1 at 0x1154: file fact.c, line 5.
(gdb) run
Breakpoint 1, factorial (n=5) at fact.c:5
5           long long result = 0;
(gdb) next
6           for (int i = 1; i <= n; i++) {
(gdb) print result
$1 = 0
(gdb) display result
1: result = 0
(gdb) next
7               result *= i;
1: result = 0
(gdb) next
6           for (int i = 1; i <= n; i++) {
1: result = 0
(gdb) info locals
i = 1
result = 0

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

size_t count_chars(const char *s)
{
    return strlen(s);
}

int main(void)
{
    const char *names[] = {"Alice", NULL, "Bob"};
    for (int i = 0; i < 3; i++) {
        printf("%zu\n", count_chars(names[i]));
    }
    return 0;
}

$ gcc -g -O0 crash.c -o crash
$ gdb ./crash
(gdb) run
5

Program received signal SIGSEGV, Segmentation fault.
__strlen_evex () at ../sysdeps/x86_64/multiarch/strlen-evex-base.S:81
(gdb) backtrace
#0  __strlen_evex () at ../sysdeps/x86_64/multiarch/strlen-evex-base.S:81
#1  0x00005555555551a5 in count_chars (s=0x0) at crash.c:6
#2  0x00005555555551fb in main () at crash.c:13

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

double average(const int *arr, int n)
{
    assert(arr != NULL);
    assert(n > 0);                        // 调用者必须保证 n > 0
    long long sum = 0;
    for (int i = 0; i < n; i++) {
        sum += arr[i];
    }
    return (double)sum / n;
}

int main(void)
{
    int scores[] = {90, 85, 77};
    printf("%.2f\n", average(scores, 3));
    printf("%.2f\n", average(scores, 0)); // 违反了前提条件
    return 0;
}

84.00
assert_demo: assert_demo.c:7: average: Assertion `n > 0' failed.
Aborted (core dumped)

// 成功返回 0，并通过 result 带回结果；失败返回 -1
int parse_score(const char *text, int *result);

int process_file(const char *in_path, const char *out_path)
{
    int status = -1;          // 默认为失败
    FILE *in = NULL;
    FILE *out = NULL;
    char *buffer = NULL;

    in = fopen(in_path, "r");
    if (in == NULL) {
        perror(in_path);
        goto cleanup;
    }
    out = fopen(out_path, "w");
    if (out == NULL) {
        perror(out_path);
        goto cleanup;
    }
    buffer = malloc(4096);
    if (buffer == NULL) {
        fprintf(stderr, "内存不足\n");
        goto cleanup;
    }

    // ……正常的处理逻辑……
    status = 0;               // 全部成功

cleanup:
    free(buffer);             // free(NULL) 是安全的
    if (out != NULL) {
        fclose(out);
    }
    if (in != NULL) {
        fclose(in);
    }
    return status;
}

#include <stdio.h>
int main(){int a[100],n,i,j,t;scanf("%d",&n);
for(i=0;i<n;i++)scanf("%d",&a[i]);
for(i=0;i<n-1;i++)for(j=0;j<n-1-i;j++)if(a[j]>a[j+1]){t=a[j];a[j]=a[j+1];a[j+1]=t;}
for(i=0;i<n;i++)printf("%d ",a[i]);return 0;}

#include <stdio.h>

#define MAX_COUNT 100

void bubble_sort(int arr[], int n)
{
    for (int i = 0; i < n - 1; i++) {
        for (int j = 0; j < n - 1 - i; j++) {
            if (arr[j] > arr[j + 1]) {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

int main(void)
{
    int numbers[MAX_COUNT];
    int count;

    if (scanf("%d", &count) != 1 || count < 1 || count > MAX_COUNT) {
        fprintf(stderr, "个数必须在 1~%d 之间\n", MAX_COUNT);
        return 1;
    }
    for (int i = 0; i < count; i++) {
        if (scanf("%d", &numbers[i]) != 1) {
            fprintf(stderr, "输入的数据有误\n");
            return 1;
        }
    }

    bubble_sort(numbers, count);

    for (int i = 0; i < count; i++) {
        printf("%d ", numbers[i]);
    }
    printf("\n");
    return 0;
}

   int max_index(const int arr[], int n)
   {
       int max = 0;
       int index = 0;
       for (int i = 1; i < n; i++) {
           if (arr[i] > max) {
               max = arr[i];
               index = i;
           }
       }
       return index;
   }

   // (a)
   int a[3] = {1, 2, 3};
   for (int i = 0; i <= 3; i++) printf("%d ", a[i]);

   // (b)
   unsigned int u = 0;
   u = u - 1;

   // (c)
   int x = 2147483647;
   x = x + 1;

   // (d)
   char s[] = "hello";
   s[0] = 'H';

   // (e)
   char *t = "hello";
   t[0] = 'H';

   // (f)
   int i = 1;
   int b = i++ + i++;

   #include <stdio.h>
   int main(){double s[5],t=0,m=0;int i;
   for(i=0;i<5;i++){scanf("%lf",&s[i]);t+=s[i];}
   for(i=0;i<5;i++)if(s[i]>m)m=s[i];
   printf("%.2f %.2f\n",t/5,m);
   for(i=0;i<5;i++)if(s[i]>=60)printf("%d pass\n",i+1);else printf("%d fail\n",i+1);}

typedef struct {
    char id[ID_LEN];                    // 学号
    char name[NAME_LEN];                // 姓名
    double scores[COURSE_COUNT];        // 各科成绩
} Student;

typedef struct {
    Student *data;                      // 指向堆上的学生数组
    size_t size;                        // 当前学生人数
    size_t capacity;                    // 当前容量
    bool modified;                      // 是否有尚未保存的修改
} StudentList;

2024001,张三,85.50,92.50,78.00
2024002,李四,90.00,88.00,95.00

启动 ──▶ 加载数据文件 ──▶ 显示菜单 ──▶ 读取选择 ──▶ 执行对应功能 ──┐
                            ▲                                      │
                            └──────────────────────────────────────┘
选择 0 ──▶ 有未保存的修改？──是──▶ 询问是否保存 ──▶ 释放内存 ──▶ 结束

/*
 * 学生成绩管理系统  student_manager.c
 *
 * 功能：添加、显示、查询、修改、删除、排序、统计学生成绩，数据保存在 CSV 文件中。
 * 编译：gcc -Wall -Wextra -std=c11 student_manager.c -o student_manager
 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <errno.h>
#include <stdbool.h>

#define ID_LEN        16                /* 学号的最大长度（含 '\0'） */
#define NAME_LEN      32                /* 姓名的最大长度（含 '\0'） */
#define COURSE_COUNT  3                 /* 课程数量 */
#define LINE_LEN      256               /* 读取一行输入的缓冲区大小 */
#define PASS_SCORE    60.0              /* 及格线 */
#define DATA_FILE     "students.csv"    /* 数据文件名 */

/* 课程名：每个课程名用两个汉字，表格才能对齐 */
static const char *COURSE_NAMES[COURSE_COUNT] = {"语文", "数学", "英语"};

/* ======================== 数据结构 ======================== */

typedef struct {
    char id[ID_LEN];                    /* 学号 */
    char name[NAME_LEN];                /* 姓名 */
    double scores[COURSE_COUNT];        /* 各科成绩 */
} Student;

typedef struct {
    Student *data;                      /* 指向堆上的学生数组 */
    size_t size;                        /* 当前学生人数 */
    size_t capacity;                    /* 当前容量 */
    bool modified;                      /* 是否有尚未保存的修改 */
} StudentList;

/* ======================== 输入工具 ======================== */

/* 判断字符串是否全部由空白字符组成（空字符串也算） */
bool is_blank(const char *s)
{
    while (*s != '\0') {
        if (!isspace((unsigned char)*s)) {
            return false;
        }
        s++;
    }
    return true;
}

/*
 * 读取一行输入，并去掉末尾的换行符。
 * 返回 1 表示成功；0 表示输入已结束；-1 表示这一行太长（多余部分已被丢弃）。
 */
int read_line(char *buf, size_t size)
{
    if (fgets(buf, (int)size, stdin) == NULL) {
        return 0;
    }
    size_t len = strcspn(buf, "\n");
    if (buf[len] == '\n') {
        buf[len] = '\0';
        return 1;
    }
    /* 没有读到换行符：说明这一行太长，把剩余的字符读走丢弃 */
    int ch;
    bool discarded = false;
    while ((ch = getchar()) != '\n' && ch != EOF) {
        discarded = true;
    }
    return discarded ? -1 : 1;
}

/* 读取一个非空、不含逗号的字符串。输入结束时返回 false */
bool input_text(const char *prompt, char *buf, size_t size)
{
    while (true) {
        printf("%s", prompt);
        int result = read_line(buf, size);
        if (result == 0) {
            return false;
        }
        if (result < 0) {
            printf("输入过长（最多 %zu 个字节），请重新输入。\n", size - 1);
        } else if (is_blank(buf)) {
            printf("不能为空，请重新输入。\n");
        } else if (strchr(buf, ',') != NULL) {
            printf("不能包含逗号，请重新输入。\n");
        } else {
            return true;
        }
    }
}

/* 读取一个 [min, max] 范围内的整数。输入结束时返回 false */
bool input_int(const char *prompt, int min, int max, int *out)
{
    char buf[LINE_LEN];
    while (true) {
        printf("%s", prompt);
        int result = read_line(buf, sizeof buf);
        if (result == 0) {
            return false;
        }
        if (result > 0) {
            char *end;
            errno = 0;
            long value = strtol(buf, &end, 10);
            if (end != buf && is_blank(end) && errno == 0 && value >= min && value <= max) {
                *out = (int)value;
                return true;
            }
        }
        printf("请输入 %d~%d 之间的整数。\n", min, max);
    }
}

/* 读取一个 0~100 之间的成绩。输入结束时返回 false */
bool input_score(const char *prompt, double *out)
{
    char buf[LINE_LEN];
    while (true) {
        printf("%s", prompt);
        int result = read_line(buf, sizeof buf);
        if (result == 0) {
            return false;
        }
        if (result > 0) {
            char *end;
            errno = 0;
            double value = strtod(buf, &end);
            if (end != buf && is_blank(end) && errno == 0 && value >= 0.0 && value <= 100.0) {
                *out = value;
                return true;
            }
        }
        printf("成绩必须是 0~100 之间的数字，请重新输入。\n");
    }
}

/* 询问用户是否确认，输入 y 或 Y 表示确认 */
bool confirm(const char *prompt)
{
    char buf[LINE_LEN];
    printf("%s（y/n）：", prompt);
    if (read_line(buf, sizeof buf) != 1) {
        return false;
    }
    return buf[0] == 'y' || buf[0] == 'Y';
}

/* ======================== 学生列表（动态数组） ======================== */

void list_init(StudentList *list)
{
    list->data = NULL;
    list->size = 0;
    list->capacity = 0;
    list->modified = false;
}

void list_free(StudentList *list)
{
    free(list->data);
    list_init(list);
}

/* 在末尾添加一名学生，空间不够时自动扩容。内存不足时返回 false */
bool list_append(StudentList *list, const Student *s)
{
    if (list->size == list->capacity) {
        size_t new_cap = (list->capacity == 0) ? 8 : list->capacity * 2;
        Student *new_data = realloc(list->data, new_cap * sizeof *new_data);
        if (new_data == NULL) {
            return false;
        }
        list->data = new_data;
        list->capacity = new_cap;
    }
    list->data[list->size] = *s;
    list->size++;
    return true;
}

/* 删除下标为 index 的学生，后面的元素依次前移 */
void list_remove_at(StudentList *list, size_t index)
{
    for (size_t i = index; i + 1 < list->size; i++) {
        list->data[i] = list->data[i + 1];
    }
    list->size--;
}

/* 按学号查找，返回下标；找不到时返回 -1 */
long list_find_by_id(const StudentList *list, const char *id)
{
    for (size_t i = 0; i < list->size; i++) {
        if (strcmp(list->data[i].id, id) == 0) {
            return (long)i;
        }
    }
    return -1;
}

/* ======================== 显示 ======================== */

double student_total(const Student *s)
{
    double total = 0.0;
    for (int c = 0; c < COURSE_COUNT; c++) {
        total += s->scores[c];
    }
    return total;
}

/*
 * printf 的宽度是按字节计算的，而一个汉字在 UTF-8 中占 3 个字节、在屏幕上占 2 列，
 * 用宽度控制中文会对不齐。所以表头直接写好空格，并把姓名放在最后一列。
 */
void print_header(void)
{
    printf("学号        ");
    for (int c = 0; c < COURSE_COUNT; c++) {
        printf("    %s", COURSE_NAMES[c]);
    }
    printf("    总分    平均  姓名\n");
}

void print_student(const Student *s)
{
    double total = student_total(s);
    printf("%-12s", s->id);
    for (int c = 0; c < COURSE_COUNT; c++) {
        printf("%8.1f", s->scores[c]);
    }
    printf("%8.1f%8.2f  %s\n", total, total / COURSE_COUNT, s->name);
}

/* ======================== 各项功能 ======================== */

/* 依次输入各科成绩 */
bool input_scores(Student *s)
{
    for (int c = 0; c < COURSE_COUNT; c++) {
        char prompt[64];
        snprintf(prompt, sizeof prompt, "%s成绩：", COURSE_NAMES[c]);
        if (!input_score(prompt, &s->scores[c])) {
            return false;
        }
    }
    return true;
}

void add_student(StudentList *list)
{
    Student s;
    if (!input_text("学号：", s.id, sizeof s.id)) {
        return;
    }
    if (list_find_by_id(list, s.id) >= 0) {
        printf("学号 %s 已存在，添加失败。\n", s.id);
        return;
    }
    if (!input_text("姓名：", s.name, sizeof s.name) || !input_scores(&s)) {
        return;
    }
    if (!list_append(list, &s)) {
        printf("内存不足，添加失败。\n");
        return;
    }
    list->modified = true;
    printf("添加成功！\n");
}

void show_all(const StudentList *list)
{
    if (list->size == 0) {
        printf("暂无学生数据。\n");
        return;
    }
    print_header();
    for (size_t i = 0; i < list->size; i++) {
        print_student(&list->data[i]);
    }
    printf("共 %zu 名学生。\n", list->size);
}

/* 按学号精确查找，或按姓名模糊查找（姓名中包含关键字即可） */
void search_student(const StudentList *list)
{
    char key[NAME_LEN];
    if (!input_text("请输入学号或姓名：", key, sizeof key)) {
        return;
    }
    size_t found = 0;
    for (size_t i = 0; i < list->size; i++) {
        const Student *s = &list->data[i];
        if (strcmp(s->id, key) == 0 || strstr(s->name, key) != NULL) {
            if (found == 0) {
                print_header();
            }
            print_student(s);
            found++;
        }
    }
    if (found == 0) {
        printf("没有找到匹配的学生。\n");
    }
}

void modify_student(StudentList *list)
{
    char id[ID_LEN];
    if (!input_text("请输入要修改的学生的学号：", id, sizeof id)) {
        return;
    }
    long index = list_find_by_id(list, id);
    if (index < 0) {
        printf("没有找到学号为 %s 的学生。\n", id);
        return;
    }
    Student *s = &list->data[index];
    print_header();
    print_student(s);
    printf("请输入新的成绩：\n");
    Student updated = *s;               /* 先修改副本，全部输入成功后再写回 */
    if (!input_scores(&updated)) {
        return;
    }
    *s = updated;
    list->modified = true;
    printf("修改成功！\n");
}

void delete_student(StudentList *list)
{
    char id[ID_LEN];
    if (!input_text("请输入要删除的学生的学号：", id, sizeof id)) {
        return;
    }
    long index = list_find_by_id(list, id);
    if (index < 0) {
        printf("没有找到学号为 %s 的学生。\n", id);
        return;
    }
    print_header();
    print_student(&list->data[index]);
    if (confirm("确定要删除这名学生吗？")) {
        list_remove_at(list, (size_t)index);
        list->modified = true;
        printf("删除成功！\n");
    } else {
        printf("已取消删除。\n");
    }
}

int compare_by_total_desc(const void *a, const void *b)
{
    double ta = student_total(a);
    double tb = student_total(b);
    return (ta < tb) - (ta > tb);       /* 总分高的排在前面 */
}

int compare_by_id(const void *a, const void *b)
{
    const Student *sa = a;
    const Student *sb = b;
    return strcmp(sa->id, sb->id);
}

void sort_students(StudentList *list)
{
    if (list->size == 0) {
        printf("暂无学生数据。\n");
        return;
    }
    int choice;
    if (!input_int("排序方式（1-按总分从高到低，2-按学号从小到大）：", 1, 2, &choice)) {
        return;
    }
    qsort(list->data, list->size, sizeof(Student),
          choice == 1 ? compare_by_total_desc : compare_by_id);
    list->modified = true;
    show_all(list);
}

void show_statistics(const StudentList *list)
{
    if (list->size == 0) {
        printf("暂无学生数据。\n");
        return;
    }
    printf("课程    平均分  最高分  最低分   及格率\n");
    for (int c = 0; c < COURSE_COUNT; c++) {
        double sum = 0.0;
        double max = list->data[0].scores[c];
        double min = max;
        size_t passed = 0;
        for (size_t i = 0; i < list->size; i++) {
            double score = list->data[i].scores[c];
            sum += score;
            if (score > max) {
                max = score;
            }
            if (score < min) {
                min = score;
            }
            if (score >= PASS_SCORE) {
                passed++;
            }
        }
        printf("%s%10.2f%8.1f%8.1f%8.1f%%\n", COURSE_NAMES[c],
               sum / list->size, max, min, 100.0 * passed / list->size);
    }

    size_t best = 0;
    for (size_t i = 1; i < list->size; i++) {
        if (student_total(&list->data[i]) > student_total(&list->data[best])) {
            best = i;
        }
    }
    printf("总分第一：%s（%s），总分 %.1f\n", list->data[best].name,
           list->data[best].id, student_total(&list->data[best]));
}

/* ======================== 文件读写 ======================== */

/* 保存为 CSV 格式，每行一名学生：学号,姓名,成绩1,成绩2,成绩3 */
bool save_to_file(StudentList *list, const char *path)
{
    FILE *fp = fopen(path, "w");
    if (fp == NULL) {
        perror(path);
        return false;
    }
    for (size_t i = 0; i < list->size; i++) {
        const Student *s = &list->data[i];
        fprintf(fp, "%s,%s", s->id, s->name);
        for (int c = 0; c < COURSE_COUNT; c++) {
            fprintf(fp, ",%.2f", s->scores[c]);
        }
        fprintf(fp, "\n");
    }
    if (fclose(fp) != 0) {
        perror(path);
        return false;
    }
    list->modified = false;
    printf("已保存 %zu 条记录到 %s。\n", list->size, path);
    return true;
}

/*
 * 在逗号处把 line 拆分成若干字段（会修改 line），空字段也算一个字段。
 * 各字段的起始地址存入 fields，返回字段个数；字段多于 max 个时返回 -1
 */
int split_fields(char *line, char *fields[], int max)
{
    int count = 0;
    char *p = line;
    while (true) {
        if (count == max) {
            return -1;                  /* 字段太多 */
        }
        fields[count] = p;
        count++;
        char *comma = strchr(p, ',');
        if (comma == NULL) {
            return count;               /* 这是最后一个字段 */
        }
        *comma = '\0';                  /* 在逗号处截断当前字段 */
        p = comma + 1;                  /* 下一个字段从逗号后面开始 */
    }
}

/* 解析 CSV 中的一行（会修改 line 的内容），成功返回 true */
bool parse_line(char *line, Student *s)
{
    char *fields[2 + COURSE_COUNT];
    int count = split_fields(line, fields, 2 + COURSE_COUNT);
    if (count != 2 + COURSE_COUNT
        || is_blank(fields[0]) || is_blank(fields[1])
        || strlen(fields[0]) >= ID_LEN || strlen(fields[1]) >= NAME_LEN) {
        return false;
    }
    strcpy(s->id, fields[0]);
    strcpy(s->name, fields[1]);
    for (int c = 0; c < COURSE_COUNT; c++) {
        char *end;
        s->scores[c] = strtod(fields[2 + c], &end);
        if (end == fields[2 + c] || !is_blank(end)
            || !(s->scores[c] >= 0.0 && s->scores[c] <= 100.0)) {   /* 这样写也能拒绝 nan */
            return false;
        }
    }
    return true;
}

bool load_from_file(StudentList *list, const char *path)
{
    FILE *fp = fopen(path, "r");
    if (fp == NULL) {
        printf("未找到数据文件 %s，将从空白数据开始。\n", path);
        return false;
    }
    char line[LINE_LEN];
    int line_no = 0;
    size_t loaded = 0;
    while (fgets(line, sizeof line, fp) != NULL) {
        line_no++;
        line[strcspn(line, "\r\n")] = '\0';     /* 去掉换行符（兼容 Windows 的 \r\n） */
        if (is_blank(line)) {
            continue;
        }
        Student s;
        if (!parse_line(line, &s)) {
            printf("警告：第 %d 行格式有误，已跳过。\n", line_no);
            continue;
        }
        if (list_find_by_id(list, s.id) >= 0) {
            printf("警告：第 %d 行的学号 %s 重复，已跳过。\n", line_no, s.id);
            continue;
        }
        if (!list_append(list, &s)) {
            printf("内存不足，停止加载。\n");
            break;
        }
        loaded++;
    }
    fclose(fp);
    printf("已从 %s 加载 %zu 条记录。\n", path, loaded);
    return true;
}

/* ======================== 主菜单 ======================== */

void print_menu(void)
{
    printf("\n=========== 学生成绩管理系统 ===========\n");
    printf("  1. 添加学生          2. 显示全部\n");
    printf("  3. 查询学生          4. 修改成绩\n");
    printf("  5. 删除学生          6. 排序\n");
    printf("  7. 成绩统计          8. 保存数据\n");
    printf("  0. 退出\n");
    printf("========================================\n");
}

int main(void)
{
    StudentList list;
    list_init(&list);
    load_from_file(&list, DATA_FILE);

    while (true) {
        print_menu();
        int choice;
        if (!input_int("请选择（0-8）：", 0, 8, &choice)) {
            choice = 0;                         /* 输入已结束，按退出处理 */
        }

        switch (choice) {
        case 1:
            add_student(&list);
            break;
        case 2:
            show_all(&list);
            break;
        case 3:
            search_student(&list);
            break;
        case 4:
            modify_student(&list);
            break;
        case 5:
            delete_student(&list);
            break;
        case 6:
            sort_students(&list);
            break;
        case 7:
            show_statistics(&list);
            break;
        case 8:
            save_to_file(&list, DATA_FILE);
            break;
        default:                                /* 0：退出 */
            if (list.modified && confirm("数据有修改，是否保存？")) {
                save_to_file(&list, DATA_FILE);
            }
            list_free(&list);
            printf("再见！\n");
            return 0;
        }
    }
}

qsort(list->data, list->size, sizeof(Student),
      choice == 1 ? compare_by_total_desc : compare_by_id);

$ gcc -Wall -Wextra -std=c11 student_manager.c -o student_manager
$ ./student_manager

$ gcc -Wall -Wextra -std=c11 -g -fsanitize=address,undefined student_manager.c -o student_manager

2024001,张三,85.50,92.50,78.00
2024002,李四,90.00,88.00,95.00
2024003,王五,72.00,58.00,66.00

已从 students.csv 加载 3 条记录。

=========== 学生成绩管理系统 ===========
  1. 添加学生          2. 显示全部
  3. 查询学生          4. 修改成绩
  5. 删除学生          6. 排序
  7. 成绩统计          8. 保存数据
  0. 退出
========================================
请选择（0-8）：2
学号            语文    数学    英语    总分    平均  姓名
2024001         85.5    92.5    78.0   256.0   85.33  张三
2024002         90.0    88.0    95.0   273.0   91.00  李四
2024003         72.0    58.0    66.0   196.0   65.33  王五
共 3 名学生。

请选择（0-8）：1
学号：2024004
姓名：赵六
语文成绩：abc
成绩必须是 0~100 之间的数字，请重新输入。
语文成绩：101
成绩必须是 0~100 之间的数字，请重新输入。
语文成绩：59.5
数学成绩：70.5
英语成绩：80
添加成功！

请选择（0-8）：7
课程    平均分  最高分  最低分   及格率
语文     76.75    90.0    59.5    75.0%
数学     77.25    92.5    58.0    75.0%
英语     79.75    95.0    66.0   100.0%
总分第一：李四（2024002），总分 273.0

请选择（0-8）：6
排序方式（1-按总分从高到低，2-按学号从小到大）：1
学号            语文    数学    英语    总分    平均  姓名
2024002         90.0    88.0    95.0   273.0   91.00  李四
2024001         85.5    92.5    78.0   256.0   85.33  张三
2024004         59.5    70.5    80.0   210.0   70.00  赵六
2024003         72.0    58.0    66.0   196.0   65.33  王五
共 4 名学生。

请选择（0-8）：0
数据有修改，是否保存？（y/n）：y
已保存 4 条记录到 students.csv。
再见！

#include <stdio.h>

int main(void)
{
    printf("====================\n");
    printf("姓名：张三\n");
    printf("专业：计算机科学与技术\n");
    printf("座右铭：Talk is cheap. Show me the code.\n");
    printf("====================\n");
    return 0;
}

#include <stdio.h>

int main(void)
{
    printf("   *\n");
    printf("  ***\n");
    printf(" *****\n");
    printf("*******\n");
    return 0;
}

#include <stdio.h>

int main(void)
{
    char c = 'm';
    printf("大写字母：%c\n", c - 'a' + 'A');       // 也可以写 c - 32
    printf("字母表中的序号：%d\n", c - 'a' + 1);
    printf("后面第 3 个字母：%c\n", c + 3);
    return 0;
}

大写字母：M
字母表中的序号：13
后面第 3 个字母：p

#include <stdio.h>

#define PI 3.14159265358979

int main(void)
{
    double r;
    printf("请输入半径：");
    scanf("%lf", &r);
    printf("周长：%.2f\n", 2 * PI * r);
    printf("面积：%.2f\n", PI * r * r);
    return 0;
}

请输入半径：3
周长：18.85
面积：28.27

#include <stdio.h>

int main(void)
{
    int a, b, c;
    printf("请输入三个整数：");
    scanf("%d %d %d", &a, &b, &c);
    int sum = a + b + c;
    printf("和：%d\n", sum);
    printf("平均值：%.2f\n", sum / 3.0);   // 用 3.0 而不是 3，避免整数除法
    return 0;
}

#include <stdio.h>

int main(void)
{
    char ch;
    printf("请输入一个大写字母：");
    scanf(" %c", &ch);
    char lower = ch - 'A' + 'a';          // 也可以写 ch + 32
    printf("小写字母：%c，ASCII 码：%d\n", lower, lower);
    return 0;
}

#include <stdio.h>

int main(void)
{
    int n;
    printf("请输入一个非负整数：");
    scanf("%d", &n);
    printf("十进制：%d\n", n);
    printf("八进制：%o\n", n);
    printf("十六进制：%x\n", n);
    printf("[%10d]\n", n);
    printf("[%-10d]\n", n);
    printf("[%010d]\n", n);
    return 0;
}

请输入一个非负整数：255
十进制：255
八进制：377
十六进制：ff
[       255]
[255       ]
[0000000255]

#include <stdio.h>

int main(void)
{
    int n;
    printf("请输入一个三位数：");
    scanf("%d", &n);
    int hundreds = n / 100;
    int tens = n / 10 % 10;
    int ones = n % 10;
    printf("百位 %d，十位 %d，个位 %d\n", hundreds, tens, ones);
    return 0;
}

#include <stdio.h>

int main(void)
{
    int total;
    printf("请输入秒数：");
    scanf("%d", &total);
    int hours = total / 3600;
    int minutes = total % 3600 / 60;
    int seconds = total % 60;
    printf("%02d:%02d:%02d\n", hours, minutes, seconds);
    return 0;
}

#include <stdio.h>

int main(void)
{
    int a, b, c;
    printf("请输入三个整数：");
    scanf("%d %d %d", &a, &b, &c);
    int max = (a > b) ? a : b;       // 先求 a、b 中的较大者
    max = (max > c) ? max : c;       // 再与 c 比较
    printf("最大值：%d\n", max);
    return 0;
}

#include <stdio.h>

int main(void)
{
    int a, b, c, temp;
    printf("请输入三个整数：");
    scanf("%d %d %d", &a, &b, &c);

    if (a > b) {            // 保证 a <= b
        temp = a;
        a = b;
        b = temp;
    }
    if (a > c) {            // 保证 a 是最小的
        temp = a;
        a = c;
        c = temp;
    }
    if (b > c) {            // 保证 b <= c
        temp = b;
        b = c;
        c = temp;
    }
    printf("从小到大：%d %d %d\n", a, b, c);
    return 0;
}

#include <stdio.h>

int main(void)
{
    int year, month, days;
    printf("请输入年份和月份：");
    scanf("%d %d", &year, &month);

    switch (month) {
    case 1: case 3: case 5: case 7: case 8: case 10: case 12:
        days = 31;
        break;
    case 4: case 6: case 9: case 11:
        days = 30;
        break;
    case 2:
        if ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0) {
            days = 29;
        } else {
            days = 28;
        }
        break;
    default:
        printf("月份输入有误\n");
        return 1;
    }
    printf("%d 年 %d 月有 %d 天\n", year, month, days);
    return 0;
}

#include <stdio.h>

int main(void)
{
    double kwh, fee;
    printf("请输入月用电量（度）：");
    if (scanf("%lf", &kwh) != 1 || kwh < 0) {
        printf("输入无效\n");
        return 1;
    }

    if (kwh <= 200) {
        fee = kwh * 0.5;
    } else if (kwh <= 400) {
        fee = 200 * 0.5 + (kwh - 200) * 0.55;
    } else {
        fee = 200 * 0.5 + 200 * 0.55 + (kwh - 400) * 0.8;
    }
    printf("应缴电费：%.2f 元\n", fee);
    return 0;
}

#include <stdio.h>

int main(void)
{
    char ch;
    printf("请输入一个字符：");
    scanf("%c", &ch);

    if (ch >= 'A' && ch <= 'Z') {
        printf("大写字母\n");
    } else if (ch >= 'a' && ch <= 'z') {
        printf("小写字母\n");
    } else if (ch >= '0' && ch <= '9') {
        printf("数字\n");
    } else {
        printf("其他字符\n");
    }
    return 0;
}

#include <stdio.h>

int main(void)
{
    int sum = 0;
    for (int i = 1; i <= 100; i += 2) {    // 从 1 开始，每次加 2，只遍历奇数
        sum += i;
    }
    printf("1~100 的奇数和：%d\n", sum);
    return 0;
}

#include <stdio.h>

int main(void)
{
    for (int n = 100; n <= 999; n++) {
        int a = n / 100;          // 百位
        int b = n / 10 % 10;      // 十位
        int c = n % 10;           // 个位
        if (a * a * a + b * b * b + c * c * c == n) {
            printf("%d\n", n);
        }
    }
    return 0;
}

#include <stdio.h>

void print_row(int spaces, int stars)
{
    for (int j = 0; j < spaces; j++) {
        putchar(' ');
    }
    for (int j = 0; j < stars; j++) {
        putchar('*');
    }
    putchar('\n');
}

int main(void)
{
    int n;
    printf("请输入 n：");
    scanf("%d", &n);
    for (int i = 1; i <= n; i++) {          // 上半部分（包括中间最宽的一行）
        print_row(n - i, 2 * i - 1);
    }
    for (int i = n - 1; i >= 1; i--) {      // 下半部分
        print_row(n - i, 2 * i - 1);
    }
    return 0;
}

#include <stdio.h>

int main(void)
{
    int n;
    printf("请输入一个正整数：");
    scanf("%d", &n);

    long long reversed = 0;
    int digits = 0;
    int temp = n;
    do {
        reversed = reversed * 10 + temp % 10;   // 把 temp 的个位接到 reversed 的末尾
        temp /= 10;
        digits++;
    } while (temp != 0);
    printf("逆序数为 %lld，共 %d 位\n", reversed, digits);
    return 0;
}

#include <stdio.h>

int main(void)
{
    long long factorial = 1, sum = 0;
    for (int i = 1; i <= 10; i++) {
        factorial *= i;         // 利用上一次的结果：i! = (i-1)! × i
        sum += factorial;
    }
    printf("1! + 2! + ... + 10! = %lld\n", sum);
    return 0;
}

#include <stdio.h>

int is_prime(int n)
{
    if (n < 2) {
        return 0;
    }
    for (int i = 2; i * i <= n; i++) {
        if (n % i == 0) {
            return 0;
        }
    }
    return 1;
}

int main(void)
{
    int count = 0;
    for (int n = 2; n < 100; n++) {
        if (is_prime(n)) {
            printf("%4d", n);
            count++;
            if (count % 10 == 0) {
                printf("\n");
            }
        }
    }
    printf("\n");
    return 0;
}

   2   3   5   7  11  13  17  19  23  29
  31  37  41  43  47  53  59  61  67  71
  73  79  83  89  97

#include <stdio.h>

int gcd(int a, int b)
{
    while (b != 0) {
        int r = a % b;
        a = b;
        b = r;
    }
    return a;
}

int lcm(int a, int b)
{
    return a / gcd(a, b) * b;    // 先除后乘，降低溢出的可能
}

int main(void)
{
    int a, b;
    printf("请输入两个正整数：");
    scanf("%d %d", &a, &b);
    printf("最大公约数：%d，最小公倍数：%d\n", gcd(a, b), lcm(a, b));
    return 0;
}

#include <stdio.h>

double power(double x, int n)          // 递归 n 次
{
    if (n == 0) {
        return 1.0;
    }
    return x * power(x, n - 1);
}

double fast_power(double x, int n)     // 递归约 log2(n) 次
{
    if (n == 0) {
        return 1.0;
    }
    double half = fast_power(x, n / 2);
    if (n % 2 == 0) {
        return half * half;            // x^n = (x^(n/2))^2
    }
    return half * half * x;            // n 为奇数时再乘一个 x
}

int main(void)
{
    printf("%.0f %.0f\n", power(2, 10), fast_power(2, 10));   // 输出：1024 1024
    return 0;
}

#include <stdio.h>

void print_binary(int n)
{
    if (n >= 2) {
        print_binary(n / 2);    // 先输出高位（除以 2 的商）
    }
    printf("%d", n % 2);        // 再输出最低位（除以 2 的余数）
}

int main(void)
{
    print_binary(13);           // 输出：1101
    printf("\n");
    return 0;
}

#include <stdio.h>

#define MAX_N 100

void reverse(int arr[], int left, int right)
{
    while (left < right) {
        int temp = arr[left];
        arr[left] = arr[right];
        arr[right] = temp;
        left++;
        right--;
    }
}

int main(void)
{
    int a[MAX_N];
    int n, k;
    printf("请输入 n（1~%d）：", MAX_N);
    if (scanf("%d", &n) != 1 || n < 1 || n > MAX_N) {
        printf("输入无效\n");
        return 1;
    }
    printf("请输入 %d 个整数：", n);
    for (int i = 0; i < n; i++) {
        scanf("%d", &a[i]);
    }
    printf("请输入 k：");
    if (scanf("%d", &k) != 1 || k < 0) {
        printf("输入无效\n");
        return 1;
    }

    k %= n;                 // 右移 n 位等于没移动
    reverse(a, 0, n - 1);
    reverse(a, 0, k - 1);
    reverse(a, k, n - 1);

    for (int i = 0; i < n; i++) {
        printf("%d ", a[i]);
    }
    printf("\n");
    return 0;
}

#include <stdio.h>
#include <stdbool.h>

#define N 10

int main(void)
{
    int a[N];
    printf("请输入 %d 个整数：", N);
    for (int i = 0; i < N; i++) {
        scanf("%d", &a[i]);
    }

    int first = a[0];
    int second = 0;
    bool has_second = false;
    for (int i = 1; i < N; i++) {
        if (a[i] > first) {                 // 出现新的最大值，原最大值退居第二
            second = first;
            has_second = true;
            first = a[i];
        } else if (a[i] < first && (!has_second || a[i] > second)) {
            second = a[i];                  // 比最大值小，但比当前的第二大值大
            has_second = true;
        }
    }

    if (has_second) {
        printf("第二大的数是 %d\n", second);
    } else {
        printf("不存在第二大的数\n");
    }
    return 0;
}

#include <stdio.h>

#define MAX_N 100

int main(void)
{
    int a[MAX_N];
    int n, x;
    printf("请输入 n（1~%d）：", MAX_N);
    if (scanf("%d", &n) != 1 || n < 1 || n > MAX_N) {
        printf("输入无效\n");
        return 1;
    }
    printf("请输入 %d 个整数：", n);
    for (int i = 0; i < n; i++) {
        scanf("%d", &a[i]);
    }
    printf("要删除的数：");
    scanf("%d", &x);

    int k = 0;
    for (int i = 0; i < n; i++) {
        if (a[i] != x) {
            a[k] = a[i];      // 保留这个元素
            k++;
        }
    }
    n = k;                    // 删除后的元素个数

    for (int i = 0; i < n; i++) {
        printf("%d ", a[i]);
    }
    printf("\n");
    return 0;
}

#include <stdio.h>

#define ROWS 10

int main(void)
{
    int t[ROWS][ROWS];
    for (int i = 0; i < ROWS; i++) {
        t[i][0] = 1;                             // 每行的第一个数
        t[i][i] = 1;                             // 每行的最后一个数
        for (int j = 1; j < i; j++) {
            t[i][j] = t[i - 1][j - 1] + t[i - 1][j];
        }
    }

    for (int i = 0; i < ROWS; i++) {
        for (int j = 0; j <= i; j++) {
            printf("%d ", t[i][j]);
        }
        printf("\n");
    }
    return 0;
}

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

int main(void)
{
    char line[256];
    printf("请输入一行文字：");
    if (fgets(line, sizeof(line), stdin) == NULL) {
        return 1;
    }

    int letters = 0, digits = 0, spaces = 0, others = 0;
    for (int i = 0; line[i] != '\0' && line[i] != '\n'; i++) {
        unsigned char c = (unsigned char)line[i];
        if (isalpha(c)) {
            letters++;
        } else if (isdigit(c)) {
            digits++;
        } else if (c == ' ') {
            spaces++;
        } else {
            others++;
        }
    }
    printf("字母 %d 个，数字 %d 个，空格 %d 个，其他 %d 个\n", letters, digits, spaces, others);
    return 0;
}

int my_strcmp(const char s1[], const char s2[])
{
    int i = 0;
    while (s1[i] != '\0' && s1[i] == s2[i]) {   // 跳过相同的部分
        i++;
    }
    return (unsigned char)s1[i] - (unsigned char)s2[i];
}

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

int main(void)
{
    char line[256];
    printf("请输入一行英文：");
    if (fgets(line, sizeof(line), stdin) == NULL) {
        return 1;
    }

    bool in_word = false;                 // 当前是否处在一个单词内部
    for (int i = 0; line[i] != '\0'; i++) {
        unsigned char c = (unsigned char)line[i];
        if (isspace(c)) {
            in_word = false;
        } else {
            if (!in_word) {               // 单词的第一个字母
                line[i] = (char)toupper(c);
            }
            in_word = true;
        }
    }
    printf("%s", line);
    return 0;
}

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

bool is_palindrome(const char s[])
{
    int i = 0;
    int j = (int)strlen(s) - 1;
    while (i < j) {
        if (tolower((unsigned char)s[i]) != tolower((unsigned char)s[j])) {
            return false;
        }
        i++;
        j--;
    }
    return true;
}

int main(void)
{
    char s[100];
    printf("请输入一个字符串：");
    if (scanf("%99s", s) != 1) {
        return 1;
    }
    printf("%s\n", is_palindrome(s) ? "是回文" : "不是回文");
    return 0;
}

#include <stdio.h>

void min_max(const int *arr, int n, int *min, int *max)
{
    *min = arr[0];
    *max = arr[0];
    for (int i = 1; i < n; i++) {
        if (arr[i] < *min) {
            *min = arr[i];
        }
        if (arr[i] > *max) {
            *max = arr[i];
        }
    }
}

int main(void)
{
    int a[] = {7, -3, 12, 5, 0};
    int lo, hi;
    min_max(a, 5, &lo, &hi);
    printf("最小值 %d，最大值 %d\n", lo, hi);   // 输出：最小值 -3，最大值 12
    return 0;
}

void reverse_array(int *arr, int n)
{
    if (n <= 0) {
        return;
    }
    int *left = arr;
    int *right = arr + n - 1;
    while (left < right) {
        int temp = *left;
        *left = *right;
        *right = temp;
        left++;
        right--;
    }
}

10 20 20 21 30 2
10 21 30 40