int gAll = 12;  // 编译通过

int gAll = f();  // 编译错误

int gAll = 12;
int g2 = gAll;  // 编译错误

const int gAll;
int g2 = gAll;  // 编译通过，但是不建议这样，尤其在大程序中。

int g2 = gAll; 
const int gAll;  // 编译错误

#include<stdio.h>
//三个变量都赋初始值0
int global = 0;  //global为全局变量
void stc()
{
    int n = 0;  //n 为局部变量
    static int sta = 0;  //sta为静态局部变量
    n++; sta++; global++;  //函数每次执行都对三个变量+1
    printf("%d ", n); printf("%d ", sta); printf("%d ", global);
}
int main()
{
    int i;
    for(i = 1; i <= 5; i++){
        stc(); printf("\n");  //三次调用函数
    }
    return 0; 
}
/* 输出：
1 1 1 
1 2 2 
1 3 3 
1 4 4 
1 5 5 
全局变量和静态局部变量都延续了上次调用的结果继续+，局部变量从初始值开始
*/

int a = -1;
printf("%d, %u", a, a);
//结果：-1, 4294967295
printf("%o, %x", a, a);
//结果：37777777777, ffffffff

printf("%d, %o, %x", 10, 10, 10);
printf("%d, %d, %d", 10, 010, 0x10);

printf("%d", 2.1 - 1 == 0.1);  //输出：0
printf("%d", 0.1 == 0.1);  //输出：1（非零）

//判断俩实数是否相等
/*
wrong:
if(f1 == f2){}
*/
fabs(f1 - f2) < 1e-12  //其实1e-8就够了

enum 枚举名 {
    枚举常量1,
    枚举常量2,
    ...
};  //带上分号

enum Color { RED, GREEN, BLUE };

int main() {
    enum Color myColor = 5; // 合法，但不推荐
    printf("%d\n", myColor); // 输出 5
    return 0;
}

enum Color {
    RED,    // 默认值为 0
    GREEN,  // 默认值为 1
    BLUE    // 默认值为 2
};

enum Day {
    MON = 1,  // MON 的值是 1
    TUE,      // TUE 的值是 2
    WED = 5,  // WED 的值是 5
    THU,      // THU 的值是 6
    FRI = 10, // FRI 的值是 10
    SAT,      // SAT 的值是 11
    SUN       // SUN 的值是 12
};

enum Color { RED, GREEN, BLUE };

int main() {
    enum Color myColor; // 定义一个枚举变量
    myColor = GREEN;    // 为变量初始化枚举常量
    printf("myColor = %d\n", myColor); // 输出 1
    scanf("%d", &myColor);  // 输入 5
    printf("%d", myColor);  // 输出 5
    printf("%d", GREEN); // 输出 1
    return 0;
}
//GREEN的值不会变成5啊，因为枚举常量的值是固定的，且在编译时已经确定。赋值给枚举变量（如 myColor）时，只是改变了变量的值，不会修改枚举常量的值。

enum { MON, TUE, WED, THU, FRI, SAT, SUN };

int main() {
    int today = WED; // 直接使用枚举常量
    printf("Today is day number: %d\n", today); // 输出 2
    return 0;
}

enum Status { OFF, ON };

int main() {
    enum Status light = OFF;

    if (light == OFF) {
        printf("Light is off\n");
    }
    return 0;
}

//状态开关机
enum State { INIT, RUNNING, STOPPED };

void checkState(enum State s) {
    switch (s) {
        case INIT:    printf("Initializing...\n"); break;
        case RUNNING: printf("Running...\n"); break;
        case STOPPED: printf("Stopped.\n"); break;
        default:      printf("Unknown state!\n");
    }
}

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

struct student {
    char name[50];  
    int age;
    long int id;
    char gender[10]; 
    double height;
    char bloodtype;
};  //这是一条C语言定义变量的语句，别忘了最后的分号；另外这段代码的作用是“声明结构类型”

int main() {
    struct student students[3];  //这是在定义一个结构变量
    // 设置第一个学生的属性
    strcpy(students[0].name, "Alice");
    students[0].age = 20;
    students[0].id = 123456789;
    strcpy(students[0].gender, "female");
    students[0].height = 1.65;
    students[0].bloodtype = 'A';

    // 设置第二个学生的属性
    strcpy(students[1].name, "Bob");
    students[1].age = 22;
    students[1].id = 987654321;
    strcpy(students[1].gender, "male");
    students[1].height = 1.80;
    students[1].bloodtype = 'B';

    // 设置第三个学生的属性
    strcpy(students[2].name, "Charlie");
    students[2].age = 19;
    students[2].id = 555555555;
    strcpy(students[2].gender, "male");
    students[2].height = 1.75;
    students[2].bloodtype = 'O';

    // 输出每个学生的信息
    for (int i = 0; i < 3; i++) {
        const char *pronoun;
        if (strcmp(students[i].gender, "male") == 0) {
            pronoun = "his";
        } else {
            pronoun = "her";
        }
        printf("%s, a %d-year-old student, %s ID is %ld.\n", students[i].name, students[i].age, pronoun, students[i].id);
    }

    return 0;
}

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

// 定义结构体
struct Person {
    char name[50];
    int age;
    float height;
};

// 通过函数初始化结构体
void initializePerson(struct Person* p, const char* name, int age, float height) {
    strcpy(p->name, name);
    p->age = age;
    p->height = height;
}

int main() {
    // 直接赋值初始化
    struct Person person1;
    person1.age = 25;
    strcpy(person1.name, "Alice");
    person1.height = 5.7;

    // 使用初始化列表初始化（C99标准及以上支持）
    struct Person person2 = {"Bob", 30, 6.0};

    // 使用初始化列表初始化，并使用类似“关键词传参”的方式
    struct Person person3 = {"zrz", .age = 18, .height = 8.0}

    // 列表初始化，若不给某int变量传值，默认0

    // 通过函数初始化
    struct Person person4;
    initializePerson(&person4, "Charlie", 22, 5.9);

    return 0;
}

struct point inputStruct(void)
{
    struct point p{/*代码块，要求与main函数里面的一样*/};
    /*代码块*/
    return p;
}

int main()
{
    struct point dest{/*代码块*/};
    dest = inputStruct();
    printf(/*语句*/)
}

/*定义一个结构变量today，里面有一个成员是month*/
struct date today;
struct date* ptoday = &today;
(*p).month = 12;
p -> month = 12;

#include<stdio.h>
struct date {
    int month;
    int day;
};

struct date* getStruct(struct date *p);
void printSturct(const struct date* p);

int main()
{
    struct date today;
    printSturct(getStruct(&today));

    *getStruct(&today) = (struct date){12, 18};
    printSturct(&today);

    getStruct(&today) -> day = 19;
    printSturct(&today);
    return 0;
}

struct date* getStruct(struct date *p)
{
    scanf("%d %d", &(p -> month), &(p -> day));
    return p;
}

void printSturct(const struct date* p)
{
    printf("%d-%d\n", p -> month, p -> day);
}

struct class {
    char* name;
    int age;
    long int id;
};

int main()
{
    struct class student[26] = {{"zrz", 18, 3240105996}, {"hhh", 18, 3240100000}};
}

struct point {
    int x;
    int y;
};

struct rectangle {
    struct point pt1;
    struct point pt2;
};

int main()
{
    struct rectangle rt1;
    struct rectangle *prt1 = &rt1;
    scanf("%d %d", &(rt1.pt1.x), &(rt1.pt1.y));
    scanf("%d %d", &(prt1 -> pt2.x), &(prt1 -> pt2.y));
}

union Person{
    char* name;
    int age;
};

typedef union person{
    char* name;
    int age;
}Person;
//使用typedef

typedef 原类型名 自定义新类型名;

typedef struct adate{
    int month;
    int day;
    int year;
} Date;
Date d = {12, 17, 2024};

#include <stdio.h>

// 为指针类型定义别名
typedef char* String;

int main() {
    String name = "Alice";
    printf("Name: %s\n", name);
    return 0;
}

#include <stdio.h>

// 定义结构体和别名
typedef struct {
    int x;
    int y;
} Point;

int main() {
    Point p = {10, 20};
    printf("Point: (%d, %d)\n", p.x, p.y);
    return 0;
}

#include <stdio.h>

// 定义枚举类型和别名
typedef enum { RED, GREEN, BLUE } Color;

int main() {
    Color favoriteColor = GREEN;
    printf("Favorite color code: %d\n", favoriteColor);
    return 0;
}

typedef enum { false, true } bool;
bool palindrome(char *s) { /*代码块*/}

#include <stdio.h>

// 定义一个长度类型
typedef unsigned int Length;

int main() {
    Length len = 100;
    printf("Length: %u\n", len);
    return 0;
}

#include <stdio.h>

// 定义函数指针类型
typedef int (*Operation)(int, int);

// 函数定义
int add(int a, int b) {
    return a + b;
}

int multiply(int a, int b) {
    return a * b;
}

int main() {
    Operation op;  // 使用别名定义函数指针变量

    op = add;
    printf("Add: %d\n", op(5, 3));

    op = multiply;
    printf("Multiply: %d\n", op(5, 3));

    return 0;
}

#include <stdio.h>

// 定义数组类型别名
typedef int Matrix[3][3];

int main() {
    Matrix mat = {
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9}
    };

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

    return 0;
}

#include <stdio.h>

// 定义位域类型
typedef struct {
    unsigned int isAvailable : 1;
    unsigned int isReadOnly  : 1;
    unsigned int isHidden    : 1;
} FileAttributes;

int main() {
    FileAttributes file = {1, 0, 1};

    printf("Available: %u, ReadOnly: %u, Hidden: %u\n",
           file.isAvailable, file.isReadOnly, file.isHidden);
    return 0;
}

#include <stdio.h>

// 定义跨平台的整型别名
typedef unsigned long long int U64;

int main() {
    U64 largeNumber = 1234567890123456789ULL;
    printf("Large number: %llu\n", largeNumber);
    return 0;
}

struct 位段名 {
    数据类型 成员名 : 位宽;
    数据类型 成员名 : 位宽;
    /*重复上述*/
};

struct U0 {
    unsigned int leading: 3;
    unsigned int FLAG1: 1;
    unsigned int FLAG2: 1;
    int trailing: 27;
};

void toBinary(int num)
{
    unsigned int mask = 1u << 31;
    for(; mask; mask >>= 1){
        printf("%d", num & mask ? 1 : 0);
    }
}

int main()
{
    struct U0 num1, num2;
    num2.leading = 2;
    num2.FLAG1 = 1;
    num2.FLAG2  =0;
    num2.trailing = 0;
    printf("please enter your number_1: ");
    scanf("%x", &*(int*)&num1);
    printf("the binary of your number_1 is: ");
    toBinary(*(int*)&num1);
    printf("\n");
    printf("the binary of your number_1 is: ");
    toBinary(*(int*)&num2);
    printf("\n");
    return 0;
}

int main()
{
    do
    {
        /* code */
    } while (/* condition */);
}

for(i = 0; ; i++){
    if(/*条件*/) break;
    else /*代码块例如cnt++*/;
}

while(1){
    /*代码块例如cnt++*/;
    if(/*条件*/) break;
}

switch (expression)
{
case /* constant-expression */:  //一定得是常量
    /* code */
    break;

default:
    break;
}

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

#define MAX_BLOCKS 10  // 最大内存块数

typedef struct {
    int id;       // 内存块 ID
    size_t size;  // 内存块大小
    int in_use;   // 是否正在使用（1 表示使用中，0 表示未使用）
} MemoryBlock;

MemoryBlock memory[MAX_BLOCKS];  // 模拟内存块数组

void initialize_memory() {
    for (int i = 0; i < MAX_BLOCKS; i++) {
        memory[i].id = i;
        memory[i].size = 0;
        memory[i].in_use = 0;
    }
}

void view_memory() {
    printf("\n=== 内存状态 ===\n");
    for (int i = 0; i < MAX_BLOCKS; i++) {
        printf("块 ID: %d, 大小: %zu 字节, 状态: %s\n",
               memory[i].id,
               memory[i].size,
               memory[i].in_use ? "已分配" : "未分配");
    }
}

void allocate_memory() {
    int id;
    size_t size;

    printf("请输入要分配的块 ID (0-%d): ", MAX_BLOCKS - 1);
    scanf("%d", &id);

    if (id < 0 || id >= MAX_BLOCKS) {
        printf("无效的块 ID！\n");
        return;
    }

    if (memory[id].in_use) {
        printf("块 ID %d 已被占用！\n", id);
        return;
    }

    printf("请输入要分配的大小 (字节): ");
    scanf("%zu", &size);

    memory[id].size = size;
    memory[id].in_use = 1;
    printf("内存块 ID %d 分配成功，大小为 %zu 字节！\n", id, size);
}

void free_memory() {
    int id;

    printf("请输入要释放的块 ID (0-%d): ", MAX_BLOCKS - 1);
    scanf("%d", &id);

    if (id < 0 || id >= MAX_BLOCKS) {
        printf("无效的块 ID！\n");
        return;
    }

    if (!memory[id].in_use) {
        printf("块 ID %d 未被分配，无需释放！\n", id);
        return;
    }

    memory[id].size = 0;
    memory[id].in_use = 0;
    printf("内存块 ID %d 已成功释放！\n", id);
}

int main() {
    int choice;

    initialize_memory();  // 初始化内存状态

    while (1) {
        // 打印菜单
        printf("\n=== 内存管理系统 ===\n");
        printf("1. 查看内存状态\n");
        printf("2. 分配内存\n");
        printf("3. 释放内存\n");
        printf("4. 退出\n");
        printf("请输入你的选择 (1-4): ");
        scanf("%d", &choice);

        switch (choice) {
            case 1:
                view_memory();
                break;
            case 2:
                allocate_memory();
                break;
            case 3:
                free_memory();
                break;
            case 4:
                printf("退出内存管理系统。\n");
                return 0;
            default:
                printf("无效的选择，请输入 1 到 4 之间的数字。\n");
        }
    }

    return 0;
}