C语言程序设计：
从第一个 Hello World到独立完成小项目

#include <stdio.h>          // 引入标准输入输出头文件

int main(void)                // 主函数：程序入口
{
    printf("Hello, World!\n");  // 输出字符串到屏幕
    return 0;                  // 返回 0 表示正常退出
}

// 单行注释：以 // 开头，到行尾结束（C99 引入）

/*
 * 多行注释：以 /* 开头，*/ 结尾
 *  常用于函数说明、临时屏蔽代码块
 */

int main(void) {
    // printf("暂时不执行\n");
    return 0;
}

# 1. 用文本编辑器写一个 hello.c（见 1.3）
# 2. 编译：gcc 把 hello.c 翻译成可执行文件 hello
$ gcc hello.c -o hello

# 3. 运行：在当前目录下执行 ./hello
$ ./hello
Hello, World!

# 常用编译选项
$ gcc -Wall -Wextra -O2 hello.c -o hello    # 开启警告、优化
$ gcc -g    hello.c -o hello               # 生成调试信息（供 gdb 使用）
$ gcc -std=c17 hello.c -o hello            # 指定 C 标准版本

hello-c/
├── src/
│   └── main.c         // 程序入口与业务逻辑
├── include/
│   └── utils.h        // 自定义头文件（可选）
├── Makefile           // 或 CMakeLists.txt，自动化编译
└── README.md

int student;            // 由字母开头的单词
int student_name;       // 下划线连接多个单词
int score1;             // 字母后接数字

// ❌ 错误：不能以数字开头
// int 1score;

// ❌ 错误：不能使用关键字
// int return;

// ⚠️ 区分大小写：Student 和 student 是两个不同的标识符

// 1) 整数常量
int a = 100;            // 十进制
int b = 0x1F;           // 十六进制 (31)
int c = 0755;           // 八进制   (493)
long d = 1000L;         // long 类型
unsigned e = 42U;      // 无符号

// 2) 浮点常量
double pi  = 3.14159;
double avo = 6.02e23;   // 科学计数法

// 3) 字符常量：用单引号
char g = 'A';          // ASCII 65
char nl = '\n';        // 换行符

// 4) 字符串常量：用双引号
char msg[] = "Hello";   // 末尾自动加 '\0'

#include <stdio.h>

int main(void)
{
    int    age;
    char  name[32];

    printf("请输入您的姓名和年龄：");
    scanf("%s %d", name, &age);          // 注意 &取地址

    printf("你好，%s！今年 %d 岁。\n", name, age);
    return 0;
}

#include <stdio.h>

// 宏常量：预处理阶段做文本替换
#define PI       3.1415926
#define MAX_LEN  256

int main(void)
{
    // 变量：值可以改变
    int    age    = 18;
    float  score  = 95.5;
    char   grade  = 'A';

    // const 常量：运行时不可修改
    const int   MAX_SCORE = 100;

    age = 19;            // 重新赋值 ✔
    // MAX_SCORE = 200;     // ❌ 编译错误：不能修改 const

    printf("PI=%.4f, MAX_SCORE=%d\n", PI, MAX_SCORE);
    return 0;
}

int    a = 10;
double b = (double)a / 3;     // 3.333...  (true division)
int    c = a / 3;             // 3          (integer division)

// ⚠️ 精度损失：double → int 时小数部分被截断（非四舍五入）
int d = (int)3.99;            // d == 3

#include <stdio.h>

int main(void) {
    int r;
    printf("请输入半径：");
    scanf("%d", &r);

    double area = 3.1415926 * r * r;
    printf("半径=%d, 面积=%.2f\n", r, area);
    return 0;
}

#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, j*i);
        printf("\n");
    }
    return 0;
}

#include <stdio.h>

// 函数定义：返回类型 + 名字 + 参数列表 + 函数体
int add(int a, int b) {
    return a + b;
}

// 没有返回值：void
void say_hello(const char* name) {
    printf("Hello, %s!\n", name);
}

int main(void) {
    say_hello("Tom");
    int s = add(3, 4);   // 函数调用
    printf("3+4=%d\n", s);
    return 0;
}

int add(int, int);    // 函数原型（参数名可省略）

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

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

void swap_wrong(int a, int b) {
    int t = a; a = b; b = t;   // 仅交换副本，原变量不变
}

void swap_ok(int *a, int *b) {
    int t = *a; *a = *b; *b = t;  // 通过地址真正交换
}

long factorial(int n) {
    if (n <= 1) return 1;      // 终止条件
    return n * factorial(n - 1); // 递归步骤
}
// factorial(5) = 5*4*3*2*1 = 120

int a[5];                       // 声明：5 个 int，未初始化
int b[5] = {1, 2, 3, 4, 5}; // 全部初始化
int c[5] = {0};                // 全为 0（部分初始化其余补 0）
int d[]  = {10, 20, 30};      // 自动推导长度 = 3

a[0] = 100;                  // 通过下标访问（下标从 0 开始）
printf("%d\n", a[4]);          // 最后一个元素
printf("size=%zu\n", sizeof a); // 20 (5×4)

int matrix[3][4] = {              // 3 行 × 4 列
    {1, 2,  3,  4},
    {5, 6,  7,  8},
    {9, 10, 11, 12}
};

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

char s1[] = "Hello";              // 自动加 \0，实际长度 6
char s2[10] = {'H','i','\0'}; // 手动构造

printf("%zu\n", strlen(s1));    // 5  (不计 \0)
strcpy(s2, "Hi");                 // 复制（不安全，建议用 strncpy）
strcat(s1, ", world!");          // 拼接
printf("%d\n", strcmp("abc", "abd")); // <0

// 字符分类与转换（ctype.h）
printf("%d %c\n", isalpha('A'), toupper('b')); // 非零 B

int  a = 10;       // 整型变量 a，值为 10
int *p = &a;        // p 是指针，指向 a 的地址

printf("a      = %d\n",   a);     // 10
printf("&a     = %p\n",   &a);   // a 的地址
printf("p      = %p\n",   p);     // 同上（p 保存的就是 &a）
printf("*p     = %d\n",   *p);    // 通过 p 间接访问：10

*p = 99;                       // 通过指针修改 a
printf("a 现在是 %d\n", a);     // 99

int a[5] = {10, 20, 30, 40, 50};
int *p = a;           // 等价于 int *p = &a[0];

printf("%d\n", *(p + 2));   // 30  (p 移动 2 个 int 长度)
printf("%d\n", p[2]);        // 30  (下标写法)

p++;                    // p 现在指向 a[1]
printf("%d\n", *p);         // 20

#include <stdlib.h>

int main(void) {
    int n;
    scanf("%d", &n);

    int *p = malloc(sizeof(int) * n);  // 申请 n 个 int
    if (p == NULL) return 1;           // 必须检查失败

    for (int i = 0; i < n; i++)
        p[i] = i * i;                          // 像普通数组一样用

    free(p);                                  // 用完必须释放
    p = NULL;                             // 避免悬空指针
    return 0;
}

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

int main(void) {
    int (*fp)(int, int) = add;   // 函数指针
    printf("%d\n", fp(3, 2));   // 5  (像函数一样调用)
    fp = sub;
    printf("%d\n", fp(3, 2));   // 1
}

int **pp;   // 二级指针：指向"指向 int 的指针"

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

// 定义结构体类型
struct Student {
    char  name[32];
    int   age;
    float score;
};

int main(void) {
    struct Student s1 = {"Tom", 18, 95.5};
    strcpy(s1.name, "Jerry");        // 修改成员
    s1.age = 19;

    struct Student *p = &s1;
    printf("%s %d %.1f\n", p->name, p->age, p->score);
}

typedef struct {
    int   id;
    char  name[32];
} Student;                  // 现在 Student 是一个类型名

Student s = {1, "Alice"};  // 不再写 struct Student

enum Color { RED, GREEN, BLUE };   // 默认 0,1,2
enum Color c = GREEN;

union Data {                     // 共用一块内存，按最大成员解释
    int   i;
    float f;
    char  c[4];
};

#include <stdio.h>

int main(void) {
    // 写文本
    FILE *fp = fopen("out.txt", "w");
    if (!fp) return 1;
    fprintf(fp, "Hello, %d\n", 42);
    fclose(fp);

    // 读文本
    char buf[128];
    fp = fopen("out.txt", "r");
    fgets(buf, sizeof buf, fp);   // 读一行
    fclose(fp);
    return 0;
}

#define PI       3.14159
#define SQR(x)  ((x)*(x))            // 函数式宏（注意括号）
#define MAX(a,b) ((a)>(b)?(a):(b))

#ifdef DEBUG
printf("[debug] x=%d\n", x);   // 仅在 DEBUG 定义时编译
#endif

#ifndef UTILS_H
#define UTILS_H

// 函数声明
int add(int, int);
void greet(const char*);

#endif

// 冒泡排序：相邻元素两两比较交换，每轮把最大元素"冒"到末尾
void bubble_sort(int a[], int n) {
    for (int i = 0; i < n - 1; i++)
        for (int j = 0; j < n - 1 - i; j++)
            if (a[j] > a[j + 1]) {
                int t = a[j]; a[j] = a[j+1]; a[j+1] = t;
            }
}

// 朴素递归 Fibonacci（教学示例，效率极低）
int fib(int n) {
    if (n < 2) return n;
    return fib(n - 1) + fib(n - 2);
}

// 迭代版：O(n) 时间 O(1) 空间（推荐）
long fib_iter(int n) {
    if (n < 2) return n;
    long a = 0, b = 1;
    for (int i = 2; i <= n; i++) {
        long c = a + b;
        a = b; b = c;
    }
    return b;
}

# 1. 编译带调试信息
$ gcc -g hello.c -o hello

# 2. 启动 gdb
$ gdb ./hello

(gdb) break main         # 设置断点
(gdb) run                # 运行
(gdb) next               # 单步（不进入函数）
(gdb) step               # 单步（进入函数）
(gdb) print x            # 查看变量
(gdb) continue           # 继续执行
(gdb) quit               # 退出