1
2
3
4
5
6

#include <stdio.h>

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

1
2

$ gcc hello.c -o hello
$ ./hello

1
2

hello.c  →  预处理(.i)  →  编译(.s)  →  汇编(.o)  →  链接(executable)
           #include展开    生成汇编代码    生成机器码     合并库函数

1
2
3
4

$ gcc -E hello.c -o hello.i    // 仅预处理
$ gcc -S hello.c -o hello.s    // 仅编译，生成汇编
$ gcc -c hello.c -o hello.o    // 仅汇编，生成目标文件
$ gcc hello.o -o hello         // 链接，生成可执行文件

1
2
3
4

-Wall        // 开启所有警告（推荐始终加上）
-g           // 生成调试信息（配合 gdb 使用）
-O2          // 优化级别2
-std=c99     // 指定C标准

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

#include <stdio.h>

int main(void) {
    int age = 25;           // 整数
    char grade = 'A';       // 单个字符
    float pi = 3.14f;       // 单精度浮点
    double e = 2.71828;     // 双精度浮点

    printf("age=%d, grade=%c, pi=%.2f, e=%.5f\n",
           age, grade, pi, e);
    return 0;
}

1
2
3
4
5
6

int    → 4 字节  (-2^31 ~ 2^31-1)
char   → 1 字节  (-128 ~ 127)
float  → 4 字节  (~6-7位有效数字)
double → 8 字节  (~15-16位有效数字)
long   → 8 字节
short  → 2 字节

1
2
3

printf("int: %zu bytes\n", sizeof(int));
printf("char: %zu bytes\n", sizeof(char));
printf("double: %zu bytes\n", sizeof(double));

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

#include <stdio.h>
int main(void) {
    int n = 42;
    double f = 3.14159;
    char c = 'X';
    char *s = "hack";

    printf("int:   %d\n", n);      // 42
    printf("float: %.2f\n", f);    // 3.14 (保留2位小数)
    printf("char:  %c\n", c);      // X
    printf("str:   %s\n", s);      // hack
    printf("hex:   %x\n", n);      // 2a (十六进制)
    printf("oct:   %o\n", n);      // 52 (八进制)
    printf("pad:   %05d\n", n);    // 00042 (补零)
    printf("left:  %-5d|\n", n);   // 42   | (左对齐)
    return 0;
}

1
2
3
4
5
6

%[flags][width][.precision]type

flags:    - (左对齐), 0 (补零), + (显示正号)
width:    最小字段宽度
precision: 小数位数 (浮点) 或最大字符数 (字符串)
type:     d(整数) f(浮点) c(字符) s(字符串) x(十六进制) %(百分号本身)

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

#include <stdio.h>
int main(void) {
    int age;
    double score;
    char name[20];

    printf("输入年龄: ");
    scanf("%d", &age);

    printf("输入分数: ");
    scanf("%lf", &score);

    printf("输入姓名: ");
    scanf("%s", name);  // 数组名本身就是地址，不加 &

    printf("你好 %s, %d岁, 成绩%.1f\n", name, age, score);
    return 0;
}

1
2
3
4
5

int n = scanf("%d %d", &a, &b);
// n == 2 表示成功读取了2个值
// n == 1 表示只读到了1个
// n == 0 表示输入不匹配
// n == EOF 表示输入结束(Ctrl+D)

1
2
3
4
5
6
7
8

int a = 17, b = 5;
printf("%d\n", a + b);   // 22  加
printf("%d\n", a - b);   // 12  减
printf("%d\n", a * b);   // 85  乘
printf("%d\n", a / b);   // 3   整数除法（截断小数）
printf("%d\n", a % b);   // 2   取余
printf("%d\n", a++);     // 17  后置++（先返回后自增）
printf("%d\n", ++a);     // 19  前置++（先自增后返回）

1
2
3
4
5
6
7

int x = 5;
x > 3 && x < 10   // true → 1
x < 3 || x > 10   // false → 0
!x                // false → 0 (x非0)

// C语言中: 0 表示假，非0 表示真
// 关系运算结果: 1(真) 或 0(假)

1
2
3
4
5
6
7
8
9
10

高 → 低:
()  []  ->  .           // 括号/成员
!  ~  ++  --  (type)    // 单目
*  /  %                 // 乘除模
+  -                    // 加减
<  <=  >  >=           // 关系
==  !=                  // 相等
&&                      // 逻辑与
||                      // 逻辑或
=  +=  -=  *=  /=      // 赋值

1
2
3
4
5
6
7
8
9
10
11

int i = 10;
double d = 3.14;

// int + double → 自动提升为 double
double result = i + d;
printf("%.2f\n", result);  // 13.14

// int / int → 整数除法（丢失小数）
int a = 7, b = 2;
double bad = a / b;       // 3.0 而不是 3.5！
printf("%.1f\n", bad);    // 3.0

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

int a = 7, b = 2;

// 先转再除
double good = (double)a / b;
printf("%.2f\n", good);  // 3.50

// 等价写法
double good2 = a / (double)b;
printf("%.2f\n", good2); // 3.50

// 只转a，b自动提升
double good3 = 1.0 * a / b;
printf("%.2f\n", good3); // 3.50

1
2
3
4
5
6
7
8

char → short → int → long → float → double

// 运算时，低精度自动向高精度提升
// 不会丢失精度

// 高 → 低（需要强制转换，可能丢数据）:
double pi = 3.14159;
int truncated = (int)pi;  // 3，小数部分被丢弃

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

// 单行注释 — C99 引入

/*
 * 多行注释
 * 适合大段说明
 */

int main(void) {
    // TODO: 实现加密功能
    int key = 42; // 密钥值
    /* 旧代码备份
    int old_key = 0;
    */
    return 0;
}

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

// ✅ 好命名
int student_count;
int maxRetries;
double cpu_temperature;

// ❌ 烂命名
int x, y, z;       // 含义不明
int a1, a2, a3;    // 毫无意义
int data;          // 什么 data？

// C 命名风格: snake_case (小写+下划线)
// 常量可用全大写: MAX_BUFFER_SIZE
// 类型名首字母大写: typedef struct Student Student;

1
2
3
4
5
6
7

// 用 gcc 编译时始终加:
$ gcc -Wall -Wextra -std=c99 -g hello.c -o hello

// -Wall   : 常见警告
// -Wextra : 额外警告
// -std=c99: 使用 C99 标准
// -g      : 调试信息

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

#include <stdio.h>
int main(void) {
    char c = 'A';
    printf("字符: %c\n", c);    // A
    printf("ASCII: %d\n", c);    // 65

    // char 本质上就是一个小整数
    char next = c + 1;
    printf("下一个: %c (%d)\n", next, next);  // B (66)

    // 大小写转换
    char lower = c + 32;  // 'a' - 'A' = 32
    printf("小写: %c\n", lower);  // a
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11

'0' = 48    '9' = 57
'A' = 65    'Z' = 90
'a' = 97    'z' = 122
'\n' = 10   '\t' = 9
'\0' = 0    ' ' = 32

// 判断数字: c >= '0' && c <= '9'
// 判断大写: c >= 'A' && c <= 'Z'
// 判断小写: c >= 'a' && c <= 'z'
// 大写转小写: c + ('a' - 'A')  即 c + 32
// 小写转大写: c - ('a' - 'A')  即 c - 32

1
2
3
4
5

\n   换行      \t   制表符
\0   空字符     \\   反斜杠
\'   单引号     \"   双引号
\r   回车      \b   退格
\x41 十六进制A  \101 八进制A

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

#include <stdio.h>
int main(void) {
    double a, b;
    char op;

    printf("输入表达式(如 3 + 5): ");
    scanf("%lf %c %lf", &a, &op, &b);

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

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

#include <stdio.h>
int main(void) {
    int score;
    printf("输入成绩: ");
    scanf("%d", &score);

    if (score >= 90) {
        printf("优秀!\n");
    } else if (score >= 60) {
        printf("及格\n");
    } else {
        printf("不及格\n");
    }
    return 0;
}

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

// 比较运算符: == != < > <= >=
// 逻辑运算符: &&(且) ||(或) !(非)

int age = 20;
char gender = 'M';

if (age >= 18 && gender == 'M') {
    printf("成年男性\n");
}

// 短路求值
if (age > 0 && 100 / age > 5) {
    // 如果 age <= 0，100/age 不会执行
    // 避免：除以0
    printf("ok\n");
}

1
2
3
4
5
6
7
8

int a = 10, b = 20;
int max = (a > b) ? a : b;
printf("max = %d\n", max);  // 20

// 等价于:
int max2;
if (a > b) max2 = a;
else max2 = b;

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

#include <stdio.h>
int main(void) {
    int day;
    printf("输入星期(1-7): ");
    scanf("%d", &day);

    switch(day) {
        case 1: printf("星期一\n"); break;
        case 2: printf("星期二\n"); break;
        case 3: printf("星期三\n"); break;
        case 4: printf("星期四\n"); break;
        case 5: printf("星期五\n"); break;
        case 6:
        case 7: printf("周末!\n"); break;  // 合并case
        default: printf("无效输入\n");
    }
    return 0;
}

1
2
3
4
5
6
7
8
9

int x = 2;
switch(x) {
    case 1: printf("一\n");
    case 2: printf("二\n");  // 匹配这里
    case 3: printf("三\n");  // 没有 break，继续执行!
    case 4: printf("四\n");  // 继续执行!
    default: printf("默认\n");
}
// 输出: 二 三 四 默认

1
2
3
4
5
6

// switch 只能比较相等 (==)
// switch 只能用于整型和字符型
// if-else 可以用任意条件

// 多个等值判断 → 用 switch 更清晰
// 范围判断 (score >= 90) → 用 if-else

1
2
3
4
5
6
7
8
9
10

#include <stdio.h>
int main(void) {
    int i = 1;
    while (i <= 5) {
        printf("%d ", i);
        i++;  // 别忘了更新条件变量!
    }
    printf("\n");
    return 0;
}

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

// 倒计时
int n = 5;
while (n > 0) {
    printf("%d... ", n);
    n--;
}
printf("发射!\n");
// 输出: 5... 4... 3... 2... 1... 发射!

// 1到100求和
int sum = 0, k = 1;
while (k <= 100) {
    sum += k;
    k++;
}
printf("sum = %d\n", sum);  // 5050

1
2
3
4
5
6
7
8
9
10

// 经典死循环（按 Ctrl+C 终止）
while (1) {
    printf("forever...\n");
}

// 等价写法
while (1) {  // 永远为真
    // 需要在内部用 break 跳出
    if (someCondition) break;
}

1
2
3
4
5
6
7
8
9
10

#include <stdio.h>
int main(void) {
    // for (初始化; 条件; 更新)
    for (int i = 0; i < 5; i++) {
        printf("%d ", i);
    }
    printf("\n");
    // 输出: 0 1 2 3 4
    return 0;
}

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

// 省略初始化
int i = 0;
for (; i < 5; i++) { ... }

// 省略条件 → 死循环
for (int i = 0;; i++) {
    if (i >= 5) break;
}

// 省略更新
for (int i = 0; i < 5;) {
    printf("%d ", i);
    i += 2;  // 手动更新
}
// 输出: 0 2 4

// 全省略 = 死循环
for (;;) { ... }

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

// 倒序
for (int i = 10; i > 0; i--) {
    printf("%d ", i);
}
// 10 9 8 7 6 5 4 3 2 1

// 步长
for (int i = 0; i <= 20; i += 5) {
    printf("%d ", i);
}
// 0 5 10 15 20

// 嵌套循环
for (int i = 1; i <= 3; i++) {
    for (int j = 1; j <= 3; j++) {
        printf("%d%d ", i, j);
    }
    printf("\n");
}

1
2
3
4
5
6
7
8
9
10
11

#include <stdio.h>
int main(void) {
    int n;
    do {
        printf("输入正数: ");
        scanf("%d", &n);
    } while (n <= 0);  // 分号不能省!

    printf("你输入了: %d\n", n);
    return 0;
}

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

// while: 先判断后执行（可能一次都不执行）
int i = 10;
while (i < 5) {
    printf("%d ", i);  // 不会执行
    i++;
}

// do-while: 先执行后判断（至少执行一次）
int j = 10;
do {
    printf("%d ", j);  // 输出 10
    j++;
} while (j < 5);

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

int choice;
do {
    printf("\n=== 菜单 ===\n");
    printf("1. 开始游戏\n");
    printf("2. 设置\n");
    printf("3. 退出\n");
    printf("选择: ");
    scanf("%d", &choice);

    switch(choice) {
        case 1: printf("游戏开始!\n"); break;
        case 2: printf("设置中...\n"); break;
        case 3: printf("再见!\n"); break;
        default: printf("无效选择\n");
    }
} while (choice != 3);

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

#include <stdio.h>
int main(void) {
    // 找到第一个能被7整除的数
    for (int i = 1; i <= 100; i++) {
        if (i % 7 == 0) {
            printf("找到: %d\n", i);
            break;  // 立即跳出for循环
        }
    }
    // 输出: 找到: 7
    return 0;
}

1
2
3
4
5
6
7
8
9

// 打印1-10中的奇数
for (int i = 1; i <= 10; i++) {
    if (i % 2 == 0) {
        continue;  // 跳过偶数
    }
    printf("%d ", i);
}
printf("\n");
// 输出: 1 3 5 7 9

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

for (int i = 0; i < 3; i++) {
    for (int j = 0; j < 3; j++) {
        if (j == 1) break;  // 只跳出内层for
        printf("%d%d ", i, j);
    }
}
// 输出: 00 10 20
// break 只影响内层循环，外层继续

// 想跳出多层？用 goto 或标志变量
int found = 0;
for (int i = 0; i < 3 && !found; i++) {
    for (int j = 0; j < 3; j++) {
        if (i == 1 && j == 1) { found = 1; break; }
    }
}

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

#include <stdio.h>
int main(void) {
    int i = 0;

loop:  // 标签
    printf("%d ", i);
    i++;
    if (i < 5) goto loop;

    printf("\n");
    return 0;
}
// 输出: 0 1 2 3 4

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

int process_file(const char *path) {
    FILE *f = fopen(path, "r");
    if (!f) goto err_open;

    char *buf = malloc(1024);
    if (!buf) goto err_malloc;

    if (fread(buf, 1, 1024, f) < 0) goto err_read;

    // ... 处理数据 ...

    free(buf);
    fclose(f);
    return 0;  // 成功

err_read:
    free(buf);
err_malloc:
    fclose(f);
err_open:
    return -1; // 失败
}

1
2
3
4
5
6
7
8
9
10
11

for (int i = 0; i < 100; i++) {
    for (int j = 0; j < 100; j++) {
        for (int k = 0; k < 100; k++) {
            if (found_target(i, j, k)) {
                goto done;  // 一次跳出三层
            }
        }
    }
}
done:
printf("找到目标!\n");

1
2
3
4
5
6
7
8
9
10

#include <stdio.h>
int main(void) {
    for (int i = 1; i <= 9; i++) {
        for (int j = 1; j <= i; j++) {
            printf("%dx%d=%-2d  ", j, i, i * j);
        }
        printf("\n");
    }
    return 0;
}

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

// 直角三角形
for (int i = 1; i <= 5; i++) {
    for (int j = 1; j <= i; j++) {
        printf("* ");
    }
    printf("\n");
}
// *
// * *
// * * *
// * * * *
// * * * * *

// 金字塔
int n = 5;
for (int i = 1; i <= n; i++) {
    for (int j = 0; j < n - i; j++) printf(" ");
    for (int j = 0; j < 2*i - 1; j++) printf("*");
    printf("\n");
}

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

// 打印100以内的质数
for (int n = 2; n <= 100; n++) {
    int is_prime = 1;
    for (int i = 2; i * i <= n; i++) {
        if (n % i == 0) {
            is_prime = 0;
            break;
        }
    }
    if (is_prime) printf("%d ", n);
}
// 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

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

#include <stdio.h>
#include <stdlib.h>  // rand(), srand()
#include <time.h>    // time()

int main(void) {
    srand(time(NULL));  // 用时间做种子
    int target = rand() % 100 + 1;  // 1~100随机数

    int guess, tries = 0;
    do {
        printf("猜一个1-100的数: ");
        scanf("%d", &guess);
        tries++;

        if (guess > target)
            printf("太大了!\n");
        else if (guess < target)
            printf("太小了!\n");
        else
            printf("恭喜! %d次猜中!\n", tries);
    } while (guess != target);

    return 0;
}

1
2
3
4
5
6
7
8
9
10

// rand() 返回 0 ~ RAND_MAX (通常2147483647)
// 不设种子 → 每次运行结果相同
srand(42);  // 固定种子 → 可复现
srand(time(NULL));  // 时间种子 → 每次不同

// 生成 [1, 100] 范围:
int n = rand() % 100 + 1;

// 生成 [min, max] 范围:
int n = rand() % (max - min + 1) + min;

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

// ===== 条件判断 =====
if (条件) { ... }
else if (条件) { ... }
else { ... }
switch(val) { case N: ...; break; default: ...; }
结果 = 条件 ? 值A : 值B;

// ===== 循环 =====
while (条件) { ... }       // 先判断后执行
for (init; cond; update) { ... }  // 计数循环
do { ... } while (条件);    // 先执行后判断

// ===== 流程控制 =====
break;       // 跳出循环/switch
continue;    // 跳过本次
goto label;  // 跳转（慎用）
return val;  // 退出函数

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

// 什么时候用什么？

// 知道循环次数 → for
for (int i = 0; i < n; i++) { ... }

// 不知道次数，可能0次 → while
while (数据可读) { 处理(数据); }

// 至少执行1次 → do-while
do { 获取输入 } while (输入无效);

// 多值等比较 → switch
switch(op) { case '+': ...; break; }

// 范围判断 → if-else
if (score >= 90) { ... }

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

#include <stdio.h>

// 函数定义: 返回类型 函数名(参数列表) { ... }
int add(int a, int b) {
    int sum = a + b;
    return sum;  // 返回结果
}

int main(void) {
    int result = add(3, 5);  // 调用函数
    printf("3 + 5 = %d\n", result);
    printf("10 + 20 = %d\n", add(10, 20));
    return 0;
}

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

// 无返回值: void
void greet(const char *name) {
    printf("Hello, %s!\n", name);
    // 不需要 return，也可以写 return;
}

// 无参数: void
int get_answer(void) {
    return 42;
}

int main(void) {
    greet("hacker");
    printf("answer = %d\n", get_answer());
    return 0;
}

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

#include <stdio.h>

void try_swap(int a, int b) {
    int tmp = a;
    a = b;
    b = tmp;
    printf("函数内: a=%d, b=%d\n", a, b);
}

int main(void) {
    int x = 10, y = 20;
    try_swap(x, y);
    printf("函数外: x=%d, y=%d\n", x, y);
    return 0;
}

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

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

int main(void) {
    int x = 10, y = 20;
    swap(&x, &y);  // 传地址
    printf("x=%d, y=%d\n", x, y);  // x=20, y=10
    return 0;
}

1
2
3
4
5
6
7

// 这两个写法完全等价
void print_arr(int arr[], int n) { ... }
void print_arr(int *arr, int n) { ... }

// 数组传给函数时退化为指针
// sizeof(arr) 在函数内是指针大小(8)，不是数组大小！
// 所以必须额外传长度参数 n

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

// return 立即结束函数并返回值
int max(int a, int b) {
    if (a > b) return a;
    return b;
    // 下面的代码不会执行
    printf("这行永远不会打印\n");
}

// void 函数用 return 提前退出
void print_if_positive(int n) {
    if (n <= 0) return;  // 提前返回
    printf("%d\n", n);
}

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

#include <stdio.h>

// 同时返回商和余数
void divmod(int a, int b, int *quotient, int *remainder) {
    *quotient = a / b;
    *remainder = a % b;
}

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

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

typedef struct {
    int quotient;
    int remainder;
} DivResult;

DivResult divmod(int a, int b) {
    DivResult r;
    r.quotient = a / b;
    r.remainder = a % b;
    return r;
}

// 使用:
DivResult r = divmod(17, 5);
printf("%d 余 %d\n", r.quotient, r.remainder);

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

#include <stdio.h>

// 方案1: 定义在调用之前
int add(int a, int b) {
    return a + b;
}
int main(void) {
    printf("%d\n", add(3, 5));  // OK
    return 0;
}

// 方案2: 先声明原型，定义放后面
int add(int a, int b);  // 函数原型(声明)
int main(void) {
    printf("%d\n", add(3, 5));
    return 0;
}
int add(int a, int b) {  // 定义
    return a + b;
}

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

// math_utils.h
#ifndef MATH_UTILS_H
#define MATH_UTILS_H

int add(int a, int b);
int max(int a, int b);
double average(int arr[], int n);

#endif

// math_utils.c
#include "math_utils.h"
int add(int a, int b) { return a + b; }
int max(int a, int b) { return a > b ? a : b; }
double average(int arr[], int n) { ... }

// main.c
#include "math_utils.h"  // 引入声明
int main(void) {
    printf("%d\n", add(3, 5));
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11

// ❌ 危险：调用未声明的函数
int main(void) {
    printf("%d\n", my_func(3));  // 编译器假设返回 int
    return 0;
}
// 如果 my_func 实际返回 double 或有不同参数类型
// → 未定义行为!

// ✅ 正确：先声明或包含头文件
// 在 C99 中隐式声明已被移除，会报错
// 始终用 gcc -Wall 编译，会警告未声明的函数

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

#include <stdio.h>

int global_var = 100;  // 全局变量：整个文件可见

void func(int param) {  // param: 函数作用域
    int local = 10;      // 局部变量：函数内可见
    printf("global=%d, param=%d, local=%d\n",
           global_var, param, local);
}

int main(void) {
    int local = 20;  // main的局部变量
    func(5);
    // printf("%d", param);  // 错误! param不可见
    // printf("%d", local);  // 这是main的local=20
    return 0;
}

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

int main(void) {
    int x = 1;
    {
        int x = 2;  // 内层x遮蔽外层x
        printf("%d\n", x);  // 2
        {
            int x = 3;
            printf("%d\n", x);  // 3
        }
        printf("%d\n", x);  // 2
    }
    printf("%d\n", x);  // 1
    return 0;
}

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

// 全局变量: 在所有函数外定义
int counter = 0;  // 全局

void increment(void) {
    counter++;  // 直接访问全局变量
}

// ⚠ 全局变量的危险:
// 1. 任何函数都能修改，难以追踪
// 2. 多线程不安全
// 3. 破坏模块化
// 4. 命名冲突

// ✅ 更好的做法: 用参数传递
void increment(int *counter) {
    (*counter)++;
}

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

#include <stdio.h>

// 阶乘: n! = n * (n-1)!
// 基线: 0! = 1
long factorial(int n) {
    if (n <= 1) return 1;     // 基线条件(base case)
    return n * factorial(n-1); // 递归调用
}

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

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

// 斐波那契: F(n) = F(n-1) + F(n-2)
// F(0)=0, F(1)=1
int fib(int n) {
    if (n <= 1) return n;
    return fib(n-1) + fib(n-2);
}
// fib(5)的调用树:
//         fib(5)
//        /      \
//     fib(4)    fib(3)
//    /    \    /    \
// fib(3) fib(2) fib(2) fib(1)
//   ...
// 指数级复杂度! O(2^n)
// fib(40) 已经很慢了

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

// 1. 基线条件(base case): 何时停止递归
// 2. 递归步骤: 向基线条件靠近
// 3. 组合结果: 如何用子问题的解

// ❌ 忘了base case → 无限递归 → 栈溢出
void bad(int n) {
    bad(n);  // 永远不会停!
}

// ❌ 没有靠近base case → 同样栈溢出
void bad2(int n) {
    if (n == 0) return;
    bad2(n);  // n没变，永远不等于0
}

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

#include <stdio.h>

int counter(void) {
    static int count = 0;  // 只初始化一次!
    count++;
    return count;
}

int main(void) {
    printf("%d\n", counter());  // 1
    printf("%d\n", counter());  // 2
    printf("%d\n", counter());  // 3
    return 0;
}

1
2
3
4
5
6
7
8
9
10

// file1.c
static int internal_data = 42;  // 仅file1.c可见!
static void helper(void) { ... }  // 仅file1.c可见!

// file2.c
extern int internal_data;  // ❌ 链接错误! static限制了可见性
// internal_data 在 file2.c 中不可访问

// static 全局变量/函数 = 文件内私有
// 类似于其他语言的 private

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

// file1.c
int shared_var = 100;  // 全局变量定义

// file2.c
extern int shared_var;  // 声明: 引用file1.c中的变量
// 不分配内存，只是告诉编译器「它在别处定义」

void use_it(void) {
    printf("%d\n", shared_var);  // 100
}

// 更好的做法: 在头文件中声明
// shared.h: extern int shared_var;
// file1.c: #include "shared.h"; int shared_var = 100;
// file2.c: #include "shared.h";

1
2
3
4
5
6
7
8
9
10

myproject/
├── main.c          // 主程序
├── math_utils.h    // 头文件(声明)
├── math_utils.c    // 实现
├── string_utils.h
├── string_utils.c
└── Makefile

// 编译:
$ gcc -Wall main.c math_utils.c string_utils.c -o myapp

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

// math_utils.h
#ifndef MATH_UTILS_H    // 如果没定义过
#define MATH_UTILS_H    // 就定义它

int add(int a, int b);
int max(int a, int b);

#endif  // MATH_UTILS_H

// 防止重复包含:
// 如果两个文件都 #include "math_utils.h"
// 没有守卫 → 重复定义错误
// 有守卫 → 第二次包含时 #ifndef 为假，跳过

// C23 新增 #pragma once (更简洁)
#pragma once
int add(int a, int b);

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

// ✅ 头文件应该放:
// - 函数声明(原型)
// - 宏定义 (#define)
// - 类型定义 (typedef, struct)
// - extern 变量声明
// - 内联函数

// ❌ 头文件不要放:
// - 函数定义(实现)  ← 放在.c文件
// - 变量定义        ← 放在.c文件
// - static 变量/函数 ← 没意义

// 例外: inline 函数可以放头文件
static inline int square(int x) {
    return x * x;
}

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

#include <stdio.h>

// 函数宏: 文本替换
#define SQUARE(x) ((x) * (x))
#define MAX(a, b) ((a) > (b) ? (a) : (b))
#define ABS(x) ((x) < 0 ? -(x) : (x))

int main(void) {
    printf("%d\n", SQUARE(5));   // 25
    printf("%d\n", MAX(3, 7));   // 7
    printf("%d\n", ABS(-42));    // 42
    return 0;
}

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

// ❌ 忘了括号
#define BAD_SQUARE(x) x * x
int result = BAD_SQUARE(3 + 2);
// 展开: 3 + 2 * 3 + 2 = 3 + 6 + 2 = 11 (不是25!)

// ✅ 正确: 每个参数和整体都加括号
#define GOOD_SQUARE(x) ((x) * (x))
// 展开: ((3 + 2) * (3 + 2)) = 25

// ❌ 副作用问题
#define BAD_MAX(a, b) ((a) > (b) ? (a) : (b))
int x = 5, y = 3;
int z = BAD_MAX(x++, y);
// x可能被自增两次!

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

// inline: 建议编译器内联展开
// 比宏安全(有类型检查)，比普通函数快(无调用开销)
static inline int square(int x) {
    return x * x;
}

int main(void) {
    int a = 5;
    printf("%d\n", square(a + 1));  // 36，安全!
    // square(a++) 也没有副作用问题
    return 0;
}

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

#include <stdio.h>
#define ROWS 5
#define COLS 5

// 0=路, 1=墙
int maze[ROWS][COLS] = {
    {0,1,0,0,0},
    {0,1,0,1,0},
    {0,0,0,1,0},
    {1,1,1,1,0},
    {0,0,0,0,0}
};
int visited[ROWS][COLS] = {0};

// 返回1表示找到出口
int solve(int r, int c) {
    // 越界 / 墙 / 已访问
    if (r<0||r>=ROWS||c<0||c>=COLS) return 0;
    if (maze[r][c]==1 || visited[r][c]) return 0;
    // 到达终点
    if (r==ROWS-1 && c==COLS-1) {
        visited[r][c] = 1;
        return 1;
    }
    visited[r][c] = 1;
    // 尝试: 下→右→上→左
    if (solve(r+1,c)) return 1;
    if (solve(r,c+1)) return 1;
    if (solve(r-1,c)) return 1;
    if (solve(r,c-1)) return 1;
    visited[r][c] = 0;  // 回溯
    return 0;
}

int main(void) {
    if (solve(0, 0)) {
        printf("找到路径!\n");
        for (int r=0;r<ROWS;r++){
            for(int c=0;c<COLS;c++)
                printf(visited[r][c]?"* ":"# ");
            printf("\n");
        }
    } else printf("无解!\n");
    return 0;
}

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

int backtrack(状态) {
    if (到达目标) {
        记录解;
        return 1;  // 成功
    }
    if (越界 || 无效) return 0;  // 失败

    标记当前状态为已访问;
    for (每个选择) {
        if (backtrack(新状态)) return 1;  // 递归
    }
    撤销标记;  // 回溯
    return 0;
}

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

#include <stdio.h>
int main(void) {
    // 声明
    int arr[5];  // 5个int，未初始化(垃圾值)

    // 声明并初始化
    int nums[] = {10, 20, 30, 40, 50};
    int scores[5] = {90, 85, 78};  // 后两个自动为0
    int zeros[100] = {0};  // 全部初始化为0

    // C99: 指定初始化
    int a[5] = {[2] = 30, [4] = 50};  // {0,0,30,0,50}

    // 访问
    printf("%d\n", nums[0]);   // 10 (下标从0开始)
    printf("%d\n", nums[4]);   // 50
    nums[2] = 99;  // 修改
    return 0;
}

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

int nums[] = {10, 20, 30, 40, 50};
int n = sizeof(nums) / sizeof(nums[0]);  // 计算元素个数!

// 求和
int sum = 0;
for (int i = 0; i < n; i++) {
    sum += nums[i];
}
printf("sum = %d, avg = %.1f\n", sum, (double)sum / n);
// sum = 150, avg = 30.0

// 查找最大值
int max = nums[0];
for (int i = 1; i < n; i++) {
    if (nums[i] > max) max = nums[i];
}
printf("max = %d\n", max);  // 50

1
2
3
4
5
6
7
8
9
10

int arr[4] = {10, 20, 30, 40};

// 内存布局(连续):
// 地址:    0x100  0x104  0x108  0x10c
// 内容:    [ 10  |  20  |  30  |  40 ]
// 下标:      [0]    [1]    [2]    [3]

// 数组名 = 首元素地址
printf("%p\n", arr);      // 0x100
printf("%p\n", &arr[0]);  // 0x100 (相同!)

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

void reverse(int arr[], int n) {
    int left = 0, right = n - 1;
    while (left < right) {
        // 交换
        int tmp = arr[left];
        arr[left] = arr[right];
        arr[right] = tmp;
        left++;
        right--;
    }
}

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

1
2
3
4
5
6
7
8
9
10
11

// 向右旋转k位: [1,2,3,4,5] k=2 → [4,5,1,2,3]
void rotate(int arr[], int n, int k) {
    k = k % n;  // 处理k > n的情况
    // 三步反转法:
    // 1. 反转整个数组: [5,4,3,2,1]
    reverse(arr, n);
    // 2. 反转前k个: [4,5,3,2,1]
    reverse(arr, k);
    // 3. 反转后n-k个: [4,5,1,2,3]
    reverse(arr + k, n - k);
}

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

// 返回去重后的长度
int dedup(int arr[], int n) {
    if (n == 0) return 0;
    int write = 1;  // 写入位置
    for (int read = 1; read < n; read++) {
        if (arr[read] != arr[read - 1]) {
            arr[write++] = arr[read];
        }
    }
    return write;  // 新长度
}

int a[] = {1,1,2,3,3,3,4,5,5};
int len = dedup(a, 9);  // len=5, a={1,2,3,4,5}

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

int matrix[3][4];  // 3行4列

// 初始化
int grid[2][3] = {
    {1, 2, 3},
    {4, 5, 6}
};

// 部分初始化(未指定的为0)
int g[3][3] = {
    {1},
    {0, 2},
    {0, 0, 3}
};
// g = {{1,0,0}, {0,2,0}, {0,0,3}}

// 全部为0
int zero[5][5] = {0};

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

int grid[3][3] = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};
int rows = 3, cols = 3;

// 打印
for (int i = 0; i < rows; i++) {
    for (int j = 0; j < cols; j++) {
        printf("%d ", grid[i][j]);
    }
    printf("\n");
}

// 对角线之和
int diag = 0;
for (int i = 0; i < rows; i++) {
    diag += grid[i][i];
}
printf("对角线 = %d\n", diag);  // 1+5+9=15

1
2
3
4
5
6
7
8
9
10
11

// 转置: 行列互换
void transpose(int m[][3], int n) {
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            int tmp = m[i][j];
            m[i][j] = m[j][i];
            m[j][i] = tmp;
        }
    }
}
// 注意: j从i+1开始，否则会交换两次还原!

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

#include <stdio.h>
int main(void) {
    // C没有string类型! 字符串是char数组
    char s1[] = "hello";  // 自动加\0, 长度6
    char s2[] = {'h','e','l','l','o','\0'};  // 手动加\0
    char s3[10] = "hi";   // 剩余位置自动填\0

    printf("%s\n", s1);   // hello
    printf("%zu\n", sizeof(s1));  // 6 (含\0)
    printf("%zu\n", strlen(s1));  // 5 (不含\0)
    return 0;
}