int scanf(const char *format, 地址1, 地址2, ...);

// if
int age = 18;
if (age >= 18) {
    printf("您已成年，可以进入。\n");
}

// if-else
int num = -5;
if (num > 0) {
    printf("正数\n");
} else {
    printf("非正数\n"); // 输出：非正数
}

// if-else阶梯
int score = 85;
if (score >= 90) {
    printf("优秀\n");
} else if (score >= 80) {
    printf("良好\n");  // 输出：良好
} else if (score >= 60) {
    printf("及格\n");
} else {
    printf("不及格\n");
}

// switch-case
char command = 'D';
switch (command) {
    case 'A':
        printf("执行添加操作\n");
        break;
    case 'D':
        printf("执行删除操作\n");  // 输出：执行删除操作
        break;
    case 'U':
        printf("执行更新操作\n");
        break;
    default:
        printf("无效指令\n");
}

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

// do-while
int choice;
do {
    printf("\n1. 开始游戏\n2. 设置\n3. 退出\n请选择: ");
    scanf("%d", &choice);
} while (choice < 1 || choice > 3);
printf("您选择了: %d\n", choice);

// for
int n = 5, factorial = 1;
for (int i = 1; i <= n; i++) {
    factorial *= i;
}
printf("%d! = %d\n", n, factorial); // 输出：5! = 120

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

// break
int arr[] = {2, 4, 6, 8, 10};
int target = 6;
for (int i = 0; i < 5; i++) {
    if (arr[i] == target) {
        printf("找到目标值 %d，位置: %d\n", target, i); // 输出：找到目标值 6，位置: 2
        break; // 找到后立即退出循环
    }
}

// continue
for (int i = 1; i <= 10; i++) {
    if (i % 2 == 0) {
        continue; // 跳过偶数
    }
    printf("%d ", i); // 输出：1 3 5 7 9
}

// goto
FILE *file = fopen("data.txt", "r");
if (!file) {
    goto cleanup; // 文件打开失败直接跳转清理
}

char buffer[256];
if (fgets(buffer, sizeof(buffer), file) == NULL) {
    goto cleanup; // 读取失败跳转清理
}

printf("文件内容: %s", buffer);

cleanup:
    if (file) fclose(file);
    printf("资源已清理\n");

// return
int max(int a, int b) {
    if (a > b) {
        return a;
    }
    return b;
}

int main() {
    printf("最大值: %d\n", max(10, 20)); // 输出：最大值: 20
    return 0;
}

类型说明符 数组名[常量表达式];  // 例如：int scores[5];

类型说明符 数组名[行数][列数];  // 例如：int matrix[3][4];

// 完全初始化 
int m1[2][3] = {{1,2,3}, {4,5,6}};  
// 部分初始化 
int m2[3][2] = {{1}, {2,3}}; // 未显式初始化的元素为0  
// 线性初始化（按行顺序） 
int m3[2][2] = {1,2,3,4};  // 1(0,0), 2(0,1), 3(1,0), 4(1,1)

char s1[] = {'H','e','l','l','o','\0'};  // 显式添加\0 
char s2[] = "World";                     // 自动添加\0 
char s3[20] = "C Programming";          // 剩余空间填充\0

void func1(int arr[]);      // 最常用 

void func2(int arr[10]);    // 长度仅作提示，不强制检查

void func3(int *arr);       // 最本质形式

void processArray(int arr[], int size) {     
    for(int i = 0; i < size; i++) { 
        // 安全操作
     }
 }  
int main() {
     int data[5] = {1,2,3,4,5};
     processArray(data, sizeof(data)/sizeof(data[0]));
 }

int arr[5] = {1,2,3,4,5};
int *p = arr; // 等价于 p = &arr[0]

// 下列表达式等价：
arr[i]  ≡  *(arr + i)  ≡  *(p + i)  ≡  p[i]

p++;     // 指向下一个元素（地址增加sizeof(int)）
p += 2;  // 前进2个元素位置
p--;     // 指向上一个元素

int matrix[3][4];
int (*ptr)[4] = matrix; // 指向含4个元素的数组指针

// 访问元素：
matrix[i][j] ≡ *(*(matrix + i) + j)

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

void printArray(int arr[], int size) {
    // 等价于 void printArray(int *arr, int size)
    for(int i=0; i<size; i++)
        printf("%d ", arr[i]);
}

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

int main() {
    int (*operation)(int, int); // 声明函数指针
    operation = add;           // 指向add函数
    printf("%d", operation(2,3)); // 输出5
    operation = sub;            // 指向sub函数
    printf("%d", operation(5,2)); // 输出3
    return 0;
}

char *str = "Hello"; // 字符串常量（只读）
char arr[] = "World"; // 字符数组（可修改）

// 常用字符串指针操作
while(*str) {       // 遍历直到'\0'
    putchar(*str);  // 输出当前字符
    str++;          // 移动到下一字符
}

typedef struct {
    int x;
    char name[20];
} Point;

Point p1 = {5, "A"};
Point *ptr = &p1;

// 访问成员：
(*ptr).x = 10;  // 方式1
ptr->x = 10;    // 方式2（更常用）
strcpy(ptr->name, "B");

char *names[] = {"Alice", "Bob", "Charlie"};
// names[0]: 指向"Alice"的指针
// names[1]: 指向"Bob"的指针

int **matrix = (int**)malloc(rows * sizeof(int*));
for(int i=0; i<rows; i++) 
    matrix[i] = (int*)malloc(cols * sizeof(int));

void process(int *arr, int size, int (*func)(int)) {
    for(int i=0; i<size; i++)
        arr[i] = func(arr[i]);
}

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

// 声明结构体变量
struct Student s1; 
struct Student s2 = {"Alice", 18, 92.5};

typedef struct {
    char title[30];
    float price;
} Book;

Book b1; // 无需再写struct关键字

// 点运算符（直接访问）
strcpy(s1.name, "Bob");
s1.age = 20;

// 箭头运算符（通过指针访问）
struct Student *ptr = &s1;
ptr->age = 21;

struct Point {
    int x;
    int y;
};

Point p1 = {10, 20};
Point p2 = p1;  // 结构体支持整体赋值（浅拷贝）

struct Example {
    char a;      // 偏移0，大小1
    int b;       // 偏移4（对齐），大小4
    short c;     // 偏移8，大小2
};               // 总大小12（10+填充2）
// sizeof(struct Example) = 12

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

struct Employee {
    char name[30];
    struct Date hire_date; // 嵌套结构体
    double salary;
};

struct Point points[5] = {
    {0,0}, {1,1}, {2,4}, {3,9}, {4,16}
};

// 访问元素
points[2].x = 5; 

Employee *e_ptr = malloc(sizeof(Employee));
strcpy(e_ptr->name, "Charlie");
e_ptr->salary = 8500.0;

// 动态数组
Employee *team = malloc(10 * sizeof(Employee));
team[0].hire_date.year = 2023;

// 传值（拷贝整个结构体）
void printPoint(struct Point p) {
    printf("(%d,%d)", p.x, p.y);
}

// 传指针（高效）
void updateSalary(Employee *e, double new_sal) {
    e->salary = new_sal;
}

// 返回结构体值（C语言支持）
struct Point createPoint(int x, int y) {
    struct Point p = {x, y};
    return p;
}

// 返回结构体指针
Employee* createEmployee(const char* name) {
    Employee *e = malloc(sizeof(Employee));
    strcpy(e->name, name);
    return e;
}

// 基础定义
union Data {
    int i;
    float f;
    char str[20];
};

// 声明变量
union Data data;

// 定义时声明变量
union {
    int count;
    char byte[4];
} packet;

// typedef 简化
typedef union {
    unsigned int raw;
    struct {
        unsigned char r;
        unsigned char g;
        unsigned char b;
        unsigned char a;
    } channels;
} Color;

union NumberConverter {
    int intValue;
    float floatValue;
};

union NumberConverter converter;

converter.intValue = 0x40490FDB;  // 写入整数
printf("Float: %f", converter.floatValue); // 输出3.141593（IEEE 754浮点表示）

data.i = 10;         // 存储整数值
printf("%d", data.i); // 输出10

data.f = 3.14;       // 存储浮点值（覆盖整数）
printf("%f", data.f); // 输出3.14
printf("%d", data.i); // 输出垃圾值（原数据被覆盖）

// malloc标准用法
double *arr = (double*)malloc(500 * sizeof(double));
if(!arr) {
    perror("内存分配失败");
    exit(EXIT_FAILURE);
}

// calloc优于malloc的场景
int *zeros = (int*)calloc(1000, sizeof(int));
// 等效于: malloc + memset(arr, 0, size)

// 正确使用realloc
int *arr = malloc(10 * sizeof(int));
int *tmp = realloc(arr, 20 * sizeof(int));
if (tmp) {
    arr = tmp;  // 使用新指针
} else {
    free(arr);  // 保留原始内存
    /* 错误处理 */
}

// realloc特殊行为
realloc(NULL, size) ≡ malloc(size)   // 空指针时新建内存
realloc(ptr, 0)     ≡ free(ptr)      // 大小为0时释放内存

// 安全释放模板
if (ptr != NULL) {
    free(ptr);
    ptr = NULL; // 关键：避免悬空指针
}

// 错误示范
free(ptr);      // 正确释放
free(ptr);      // 二次释放 → 程序崩溃
printf("%d", *ptr); // 使用已释放指针 → 未定义行为

FILE *file_ptr; // 声明文件指针

FILE *fopen(const char *filename, const char *mode);

int fclose(FILE *stream);

int fgetc(FILE *stream);     // 读字符
int fputc(int char, FILE *stream); // 写字符

// 示例：复制文件内容
int ch;
while ((ch = fgetc(source)) != EOF) {
    fputc(ch, dest);
}

char *fgets(char *str, int n, FILE *stream);
int fputs(const char *str, FILE *stream);

// 示例：逐行读取
char buffer[256];
while (fgets(buffer, sizeof(buffer), file)) {
    // 处理每行内容
}

int fprintf(FILE *stream, const char *format, ...);
int fscanf(FILE *stream, const char *format, ...);

// 示例：写入结构化数据
struct Student s = {101, "Alice", 92.5};
fprintf(file, "%d,%s,%.1f\n", s.id, s.name, s.grade);

// 示例：读取结构化数据
struct Student s;
fscanf(file, "%d,%[^,],%f\n", &s.id, s.name, &s.grade);