void test(){
    printf("ok\n");
}
int main(){
    test(100); // 正常输出ok，虽然这里传了个100过去，而test函数并没有形参去接它，但是函数依然没有报错，正常执行了。这是c语言比较模棱两可的地方。
    return 0;
}

void test(void){ // 后面那个void意思是我这个函数它是不需要参数的
    printf("ok\n");
}
int main(){
    test(100); // 这个时候如果还传个100过去，那编译器就会报警告了
    return 0;
}

int b = -10; // 那么b在内存中它很可能是存了个：0xf6ffffff
// 解释：b的原码、反码、补码：
// 10000000000000000000000000001010 - 原码
// 11111111111111111111111111110101 - 反码
// 11111111111111111111111111110110 - 补码
// 补码十六进制：0xfffffff6
// 而在内存中它是按照字节倒着存的，所以变成了：0xf6ffffff

// 比方说有数：0x11223344这样一个数
// 那在内存中可以这样存：11 22 33 44，也可以这样存：44 33 22 11，当然也可以这样存：11 33 22 44，存的方法有千千万万种，但是最人性化的也就两种：11 22 33 44 和 44 33 22 11。这两种模式分别叫大端模式和小端模式

int check_sys(){
    int a = 1;
    // 返回1，小端
    // 返回0，大端
    return *(char*)&a;
}

// 已知大端存储
int main(){
    unsigned int a = 0x1234; // 由于是大端存储，因此a在内存中这么存：（假设从左到右是低地址到高地址）00 00 12 34 
    unsigned char b = *(unsigned char*)&a; // 取a的地址，强转成unsigned char*，意味着它的步长变1，再解引用拿到的应该是00这个字节，所以输出为0
    printf("%d\n", b); // 0
    return 0;
}

int main(){
    union{
        short k;
        char i[2];
    }*s, a;
    s = &a;
    s->i[0] = 0x39;
    s->i[1] = 0x38;
    printf("%x\n", a.k); // 由于测试机器是小端，因此低位放低地址，高位放高地址，显然i[1]（0x38）是低位，i[0]（0x39）是高位，因此0x38放在低地址，0x39放在高地址，因此打印出来是3839
    return 0;
}

int main(){
    char a = -128;
    char b = 128;
    printf("%u\n", a); // 4294967168
    printf("%u\n", b); // 4294967168
    return 0;
}

unsigned int a = 0; // 00000000000000000000000000000000
a -= 1; // 11111111111111111111111111111111
printf("%u\n", a); // 由于是无符号数，因此输出为4294967295（11111111111111111111111111111111）

unsigned int i;
for(i = 9; i >= 0; i--){
    printf("%u\n", i);
}
// 结果就是死循环

int main(){
    char a[1000];
    int i;
    for(i = 0; i < 1000; i++){
        a[i] = -1 - i; 
    }
    printf("%d\n", strlen(a)); // 128 + 127 = 255
    return 0;
}
// 解释：11111111, 11111110, 11111101, ..., 10000000, 01111111, 01111110, ..., 00000000, 11111111, 11111110, ...
// 记住一点，char型永远都是截取比特位最后8位，如果进位那也是截取比特位最后8位，如果00000000减一不够减的时候向第9位借位之后还是会截取比特位最后8位，因此00000000减一就变成11111111

float f = 5.5;
// 5.5
// 101.1
// (-1)^0 * 1.011 * 2^2
// S = 0
// M = 1.011
// E = 2 （E此时还需要加上127，也就是说E最后存进去的是2 + 127 = 129 -> 10000001）
// 0 10000001 011 00000000000000000000 -> 0100 0000 1011 0000 0000 0000 0000 0000
// 0x40b00000

int n = 9;
float* pFloat = (float*)&n;
printf("%d\n", n); // 9
printf("%f\n", *pFloat); // 0.000000

*pFloat = 9.0;
printf("%d\n", n); // 1091567616
printf("%f\n", *pFloat); // 9.0

int arr[10] = {1,2,3,4,5};
int* p = arr; // 数组名表示首元素地址
// *(p + 2) == p[2] == *(arr + 2) == arr[2]
// 从这里可以看出p和arr其实是等价的

// ”abcde"直接赋给指针p那是不现实的，因为指针p大小只有4个字节，而"abcde"是5个字节，根本放不下
// 实际上，字符串要赋值给指针，不是把整个字符串赋值给指针，而是把字符串首字符的地址赋值给指针
char* p = "abcde"; // "abcde"是一个常量字符串
printf("%c\n", *p); // a
printf("%s\n", p); // abcde
// 相当于发生了这些事：首先在内存中开辟空间存放常量字符串”abcde\0“，并且首字符a的地址是0x0012ff44，然后还会为指针p开辟空间并且指针p里面存放首字符a的地址，也就是0x0012ff44

const char* p = "abcde"; // 使用const修饰*p，那么就不怕它被非法修改了

char arr1[] = "abc";
char arr2[] = "abc";
char* p1 = "abc"; // 最好写成 const char* p1 = "abc"
char* p2 = "abc"; // 最好写成 const char* p2 = "abc"
// 那么此时arr1 != arr2；p1 == p2
// 解释：如果”abc“是常量字符串，为了节省空间，”abc“就只需要创建并且存储一份在内存中就可以了，因此p1和p2指向的是同一块内存区域；而数组不一样，数组不管内容一不一样它都是需要重新创建并存储的

// int *p = NULL; // p是整型指针 - 指向整型的指针 - 可以存放整型的地址
// char* pc = NULL; // pc是字符指针 - 指向字符的指针 - 可以存放字符的地址
					// 数组指针 - 指向数组的指针 - 存放数组的地址
// int arr[10] = {0};
// arr - 首元素的地址
// &arr[0] - 首元素的地址
// &arr - 数组的地址
int arr[10] = {1, 2, 3, 4};
int* p1[10] = &arr; // ❌ 由于[]的优先级高于*，因此p1先和[结合了，那么它就是一个数组而不是指针了。因此这种写法错误！
int (*p)[10] = &arr; // ✔ 相当于*先和p结合了，那么它就是一个指针，后面的[10]说明它指向的是一个存放10个元素的数组，那么这个数组存放的元素是什么类型的呢？前面的int说明存放的元素是int型的
// 那么上面的p就是数组指针

int arr[5]; // arr是一个5个元素的整型数组
int* parr1[10]; // parr1 是一个数组，数组有10个元素，每个元素的类型是int*，parr1是指针数组
int (*parr2)[10]; // parr2 是一个指针，该指针指向了一个数组，数组有10个元素，每个元素的类型是int，parr2是数组指针
int (* parr3[10])[5]; // 首先由于[]优先级比*高，因此parr3先跟[]结合，因此parr3首先应该被定义为是一个数组。parr3是一个数组，该数组有10个元素，每个元素是一个类型为int(*)[5]的数组指针，该数组指针指向的数组有5个元素，每个元素的类型是int
// 解释一下如何得到int (* parr3[10])[5]中每一个元素的类型：首先int (* parr3[10])[5]中每一个元素应当为int (* parr3)[5]，去掉名称parr3，剩下的就是类型，因此类型是int(*)[5]；也可以简单直接一点，直接把数组名和方括号一起去了，也就是说把parr3[10]去了，那么剩下的int(*)[5]也就是元素类型

// 写出一个指向char* arr[5];的数组指针
char* (*parr)[5] = &arr;

// 使用数组指针打印下面的数组
int arr[10] = {1,2,3,4,5,6,7,8,9,10};
int (*parr)[10] = &arr;
int i = 0;
for(i = 0; i < 10 ;i++){
    // printf("%d ", (*parr)[i]);
    // 或者：
    printf("%d ", *(*parr + i));
}

// 有二维数组：
int arr[3][5] = {{1,2,3,4,5}, {2,3,4,5,6}, {3,4,5,6,7}};
// 有函数用于打印该二维数组：
print1(arr, 3, 5); // arr - 数组名 - 数组名就是数组首元素地址
// 那么问题来了，二维数组首元素是谁？答：不是1，而是{1,2,3,4,5}这个数组（该数组类型是int [5]）
// 注意，在说二维数组首元素的时候我们需要先将二维数组想象成一维数组，再去讨论它的首元素
// 现在我们搞清楚传入print1函数的arr是个什么类型了（其实就是一个一维数组的地址），既然是数组的地址，那么我们就应该用数组指针去接它

void print1(int (*p)[5], int x, int y){
    int i = 0;
    int j = 0;
    for(i = 0; i < x; i++){
        for(j = 0; j < y; j++){
            // printf("%d ", *(*(p + i) + j)); 
            // 或 printf("%d ", (*(p + i))[j])
            // 或者直接：
            printf("%d", p[i][j]);
        }
        printf("\n");
    }
}
// 为了理解(*(p + i))[j]，这里做一下说明
// 假设有数组：
int arr[2] = {1,2};
int* parr = arr;
// 则可以这样打印数组：
for(int i = 0; i < 2; i++){
    printf("%d ", parr[i]);
}

int arr1[] = {1, 2, 3, 4, 5};
int arr2[] = {2, 3, 4, 5, 6};
int arr3[] = {3, 4, 5, 6, 7};
int* parr[] = {arr1, arr2, arr3};

void test(int arr[]){} // ok
void test(int arr[10]){} // ok 这个10写跟不写没区别，就算写了写错了也没事，反正它是没用的
void test(int *arr){} // ok
void test2(int *arr[20]){} // ok 这个20写跟不写没区别，就算写了写错了也没事，反正它是没用的
void test2(int **arr){} // ok

int main(){
    int arr[10] = {0};
    int *arr2[20] = {0};
    test(arr);
    test2(arr2);
    return 0;
}

void test(int arr[3][5]){} // ok
void test(int arr[][5]){} // ok
void test2(int *arr); // err，二维数组首元素应该是一个一维数组，而整型指针应该是用来存放整型的地址的
void test2(int **arr); // err，二维数组首元素应该是一个一维数组，而二级整型指针应该是用来存放一级整型指针的地址的
void test2(int *arr[5]); // err
void test2(int (*arr)[5]); // ok
int main(){
    int arr[3][5] = {0};
    test(arr);
    test2(arr);
    return 0;
}

int Add(int x, int y){}
int main(){
    // &函数名 和 函数名 都是函数的地址，它俩没有任何区别，一模一样
    printf("%p\n", &Add); // 005310E1
    printf("%p\n", Add); // 005310E1
    // 那么函数指针该怎么写呢？？、
    int (*fp)(int, int) = Add; // 解释：首先它是个指针，因此是*fp，其次它需要两个参数，分别是int和int，因此后面跟(int, int)，然后函数的返回值是int，因此前面写int
    (*fp)(3,4); // 通过函数指针调用函数
    return 0;
}

void (*pfun1)();
void *pfun2();
// 首先，能存放存储地址，就要求pfun1或者pfun2是指针，那哪个是指针？答案是：
// pfun1可以存放。pfun1先和*结合，说明pfun1是指针，指针指向的是一个函数，指向的函数无参数，返回值类型为void
// 而第二行代码中pfun2首先跟()结合，因此这行代码仅仅只是一个函数的声明，参数无，返回类型void*，pfun2只是这个函数的名称而已

// 还是一样，去掉函数名剩下的就是类型
// 比方说：
void test(double x, int y){}
int main(){
    void (*fp)(double, int) = test; // 那么函数指针fp的类型就是void (*)(double, int)
    return 0;
}

void test(int x){
    return x + 1;
}
int main(){
    int a = 10;
    void (*pa)(int) = test; 
    // 这里pa、*pa、**pa和***pa完全一样，没有区别，*其实是摆设，加与不加都一样。
    // 那么怎么理解呢？思考一下，直接调用test函数是怎么调用的呢：test(10)，我们把这里的test想象成地址，那么pa存的就是test的地址，那首先pa(a)就好理解了，因为pa里面存的就是test的地址，那直接调用就可以了；(*pa)(a)其实也好理解，因为pa存的是test的地址，那么我们解引用拿到test函数再去调用，也就变成了(*pa)(a)
    printf("%d\n", pa(a)); // 11
    printf("%d\n", (*pa)(a)); // 11
    printf("%d\n", (**pa)(a)); // 11 一般不这么写
    printf("%d\n", (***pa)(a)); // 11 一般不这么写
    return 0;
}

(*(void (*)())0)(); // 首先中间的一段”void (*)()“它表示函数指针类型，而类型包了个括号放在数字0前面，显然是在强制类型转换，那这里的意思就是把0强制类型转换成：void (*)() 函数指针类型，而0就是一个函数的地址，然后第一个*就要发挥作用了，它的意思是解引用拿到函数指针0所指向的函数，最后我们可以看到代码末尾有一对小括号，那就是在调用这个函数

void (*signal(int, void(*)(int)))(int); // 首先我们先思考signal(int, void(*)(int))，它的意思显然是函数声明，首先函数名是signal，然后第一个形参是int型的数，第二个形参是void(*)(int)类型的函数指针
// 然后我们来分析这个函数的返回类型是什么，思考一下，如果是int Add(int, int);这样的函数声明，显然它的返回类型是int，那我们是怎么得到它的返回类型就是int的呢？其实是去掉了Add(int, int)，剩下了int，那么这个剩下的int就说明了Add函数的返回类型是int。
// 那么这里的函数也一样，我们首先去掉signal(int, void(*)(int))，剩下了void (*)(int)，那就能说明该函数的返回类型了，就是void (*)(int)，那为什么不写成一般情况下函数声明的形式，比方说void (*)(int) signal(int, void(*)(int))呢？那是应为这样声明是非法的，如果返回类型是函数指针，那么函数名必须写到void (*)(int)中的*的右边
// 所以总结一下这行代码意思是一个名为signal的函数的声明，该函数需要一个int型的数和一个void(*)(int)型的函数指针作为参数，它的返回类型是void(*)(int)型的函数指针

// typedef void(*)(int) pfun_t; // ❌
typedef void(*pfun_t)(int); // ✔

// 这个时候我们就可以简化上面的代码语句了
pfun_t signal(int, pfun_t);

int Add(int, int){}
int Sub(int, int){}
// 将函数指针作为参数传入函数
void Calc(int (*pf)(int, int)){
    printf("%d\n", pf(2, 1));
}
int main(){
    Calc(Add);
    Calc(Sub);
    return 0;
}

// 编写通用的冒泡排序函数
void swap(char* buf1, char* buf2, int width){
    int i = 0;
    for(i = 0; i < width; i++){
        char tmp = *buf1;
        *buf1 = *buf2;
        *buf2 = temp;
        buf1++;
        buf2++;
    }
}
void bubble_sort(void* base, int sz, int width, int(*cmp)(const void* e1, const void* e2)){
    int i = 0;
    // 趟数
    for(i = 0; i < sz - 1; i++){
        // 每一趟比较的对数
        int j = 0;
        for(j = 0; j < sz - 1 - i; j++){
            if(cmp((char*)base + j * width, (char*)base + (j + 1) * width) > 0){
                // 交换
                swap((char*)base + j * width, (char*)base + (j + 1) * width, width);
            }
        }
    }
}

int a = 0;
char c = 'a';
void* p = &a; // ✔
p = &c; // ✔

// qsort函数的声明
void qsort(void* base, size_t num, size_t wid, int(*cmp)(const void* e1, const void* e2));

void* p = &a;
*p; // ❌

void* p = &a;
p++; // ❌

// 如果要排序的数组里面是整型数
int cmp(const void* e1, const void* e2){
    // return *e1 - *e2; // ❌
    return *(int*)e1 - *(int*)e2; // ✔ 这里把e1和e2强制类型转换成int*型的指针
}
// 如果要排序的数组里面是浮点型数
int cmp(const void* e1, const void* e2){
    // return *(float*)e1 - *(float*)e2; // ✔ 这里把e1和e2强制类型转换成float*型的指针
    // 但是上面这种写法可能会有问题，因为函数的返回类型是int，但是两个浮点型的数做加减法得到的也是一个浮点型的数
    // 所以最好还是这么写：
    // if (*(float*)e1 == *(float*)e2) return 0;
    // else if (*(float*)e1 > *(float*)e2) return 1;
    // else return -1;
    
    // 当然也可以这么写：
    return ((int)(*(float*)e1 - *(float*)e2)); // 意思就是将两个浮点型的数做加减运算之后再将结果强制类型转换成int型
}

struct Stu{
    char name[20];
    int age;
};

// 现在有结构体数组：struct Stu s[3] = {{"zhangsan", 20}, {"lisi", 30}, {"wangwu", 10}};
// 那么怎么写比较函数来对数组s按照年龄进行排序呢？如下：
int cmp_stu_by_age(const void* e1, const void* e2){
    return ((struct Stu*)e1)->age - ((struct Stu*)e2)->age;
}
// 那么怎么写比较函数来对数组s按照名字进行排序呢？如下：
int cmp_stu_by_name(const void* e1, const void* e2){
    // 比较名字就是比较字符串
    // 字符串比较不能直接用><=来比较，应该用strcmp函数
    return strcmp(((struct Stu*)e1)->name, ((struct Stu*)e2)->name);
}

int Add(int x, int y){}
int Sub(int x, int y){}
int Mul(int x, int y){}
int Div(int x, int y){}
int main(){
    int (*pa)(int, int) = Add;
    int (*pa[4])(int, int) = {Add, Sub, Mul, Div}; // 函数指针数组。它所存放的元素的类型是int (*)(int, int)
    int i = 0;
    for(i = 0; i < 4; i++){
        printf("%d\n", pa[i](2,3));
    }
}

int (*par[10])(); // ✔
int (*par[])(); // ✔
int *par[10](); // ❌
int (*)() par[10]; // ❌

int Add(int x, int y){}
int Sub(int x, int y){}
int Mul(int x, int y){}
int Div(int x, int y){}
int main(){
    int input = 0;
    // pf 是一个函数指针数组 - 转移表
    int (*pf[])(int, int) = {0, Add, Sub, Mul, Div};
    do{
        printf("请输入0-5之间的整数:>");
        scanf("%d", &input);
        if(input >= 1 && input <= 4){
            int res = pf[input](2, 3);
            printf("%d\n", res);
        }else if(input == 0){
            printf("退出!\n");
        }else{
            printf("错误!\n");
        }
    }while(input);
    return 0;
}

int main(){
    int arr[10] = {0};
    int (*p)[10] = &arr; // 取出数组的地址
    int(*pf)(int, int); // 函数指针
    int (*pfArr[4])(int, int); // pfArr是一个数组 - 函数指针的数组
    int(*(*ppfArr)[4])(int, int); // ppfArr是一个指向[函数指针数组]的指针，指针指向的数组有4个元素，每一个元素的类型是一个函数指针，每一个函数指针的类型是int(*)(int, int)
}

int main(){
    int a[] = {1, 2, 3, 4}; // 4 * 4 = 16
    printf("%d\n", sizeof(a)); // 16 sizeof(数组名) - 计算的是数组总大小 - 单位是字节
    printf("%d\n", sizeof(a + 0)); // 4/8 数组名在这里表示首元素的地址，a+0还是首元素地址，地址的大小就是4/8个字节
    printf("%d\n", sizeof(*a)); // 4 数组名表示首元素的地址，*a就是首元素，sizeof(*a)就是4
    printf("%d\n", sizeof(a + 1)); // 4/8 数组名在这里表示首元素的地址，a+1是第2个元素的地址，地址的大小就是4/8个字节
    printf("%d\n", sizeof(a[1])); // 4 第二个元素的大小
    printf("%d\n", sizeof(&a)); // 4/8 &a取出的是数组的地址，但是数组的地址那也是地址，地址的大小就是4/8个字节
    printf("%d\n", sizeof(*&a)); // 16 &a是数组的地址，数组地址解引用访问数组（相当于*和&抵消了），因此sizeof(*&a)计算的就是sizeof(a)的值
    printf("%d\n", sizeof(&a + 1)); // 4/8 &a是数组的地址，&a+1虽然地址跳过整个数组，但还是地址
    printf("%d\n", sizeof(&a[0])); // 4/8 &a[0]是第一个元素的地址
    printf("%d\n", sizeof(&a[0] + 1)); // 4/8 &a[0]+1 是第二个元素的地址
    return 0;
}

int main(){
    int a[5] = {1,2,3,4,5};
    int* ptr = (int *)(&a + 1);
    printf("%d, %d\n", *(a + 1), *(ptr - 1)); // 2, 5
    return 0;
}

int main(){
    char arr[] = {'a', 'b', 'c', 'd', 'e', 'f'};
    printf("%d\n", sizeof(arr)); // 6 sizeof计算的是数组大小
    printf("%d\n", sizeof(arr + 0)); // 4/8 arr是首元素的地址，arr+0还是首元素的地址
    printf("%d\n", sizeof(*arr)); // 1 arr是首元素的地址，*arr就是首元素，首元素是一个字符，而字符大小是一个字节
    printf("%d\n", sizeof(arr[1])); // 1 
    printf("%d\n", sizeof(&arr)); // 4/8 &arr虽然是数组的地址，但还是地址
    printf("%d\n", sizeof(&arr + 1)); // 4/8 &arr+1是跳过整个数组后的地址
    printf("%d\n", sizeof(&arr[0] + 1)); // 4/8 是第二个元素的地址
    return 0;
}

int main(){
    char arr[] = {'a', 'b', 'c', 'd', 'e', 'f'};
    printf("%d\n", strlen(arr)); // arr首元素地址往后找到'\0'才结束，因此是随机值
    printf("%d\n", strlen(arr + 0)); // arr+0 还是arr首元素地址，还是从arr首元素地址往后找到'\0'才结束，因此是随机值
    printf("%d\n", strlen(*arr)); // *arr是解引用arr首元素地址，这里是'a'，而strlen接收的参数是地址，因此这里传'a'相当于传了97，而访问地址97的内存是非法的，因此会报错
    printf("%d\n", strlen(arr[1])); // arr[1]是arr第二个元素地址，这里是'b'，而strlen接收的参数是地址，因此这里传'b'相当于传了98，而访问地址98的内存是非法的，因此会报错
    printf("%d\n", strlen(&arr)); // &arr是整个arr数组的地址，因此还是从arr首元素地址往后找到'\0'才结束，因此是随机值
    printf("%d\n", strlen(&arr + 1)); // &arr+1是跳过整个arr数组的地址，因此是从跳过整个arr数组的地址的那个地址往后找到'\0'才结束，因此是随机值
    printf("%d\n", strlen(&arr[0] + 1)); // &arr[0]+1是第二个元素的地址，因此是从第二个元素的地址往后找到'\0'才结束，因此是随机值
	return 0;
}

int main(){
    char arr[] = "abcdef";
    printf("%d\n", sizeof(arr)); // 7 sizeof(arr)计算的是数组的大小
    printf("%d\n", sizeof(arr + 0)); // 4/8 计算的是地址的大小 - arr+0 是首元素的地址
    printf("%d\n", sizeof(*arr)); // 1 *arr是首元素'a'，sizeof(*arr)计算首元素'a'的大小
    printf("%d\n", sizeof(arr[1])); // 1 arr[1]是第二个元素，sizeof(arr[1])计算的是第二个元素的大小
    printf("%d\n", sizeof(&arr)); // 4/8 &arr虽然是数组的地址，但也是地址
    printf("%d\n", sizeof(&arr + 1)); // 4/8 &arr+1是跳过整个数组后的地址，但也是地址
    printf("%d\n", sizeof(&arr[0] + 1)); // 4/8 &arr[0]+1是第二个元素的地址
    return 0;
}

int main(){
    char arr[] = "abcdef";
    printf("%d\n", strlen(arr)); // 6
    printf("%d\n", strlen(arr + 0)); // 6
    printf("%d\n", strlen(*arr)); // err
    printf("%d\n", strlen(arr[1])); // err
    printf("%d\n", strlen(&arr)); // 6 &arr是数组的地址，需要用数组指针去接：char(*p)[7] = &arr;但是strlen接收的参数实际上是一个字符指针，因此这里会报警告，但是并不影响使用，因为它会把传进去的数组指针当成字符指针去使用
    printf("%d\n", strlen(&arr + 1)); // 随机值 &arr是整个数组的地址，&arr+1还是整个数组的地址，需要用数组指针去接：char(*p)[] = &arr+1;但是strlen接收的参数实际上是一个字符指针，因此这里会报警告，但是并不影响使用，因为它会把传进去的数组指针当成字符指针去使用
    printf("%d\n", strlen(&arr[0] + 1)); // 5
    return 0;
}

int main(){
    char* p = "abcdef";
    printf("%d\n", sizeof(p)); // 4/8 计算指针变量p的大小
    printf("%d\n", sizeof(p + 1)); // 4/8 p+1得到的是字符'b'的地址
    printf("%d\n", sizeof(*p)); // 1 *p就是字符串的第一个字符'a'的大小
    printf("%d\n", sizeof(p[0])); // 1 int arr[10]; arr[0] == *(arr+0)  因此p[0] == *(p+0) == 'a'
    printf("%d\n", sizeof(&p)); // 4/8 &p取的是指针p的地址，所以计算的是地址的大小
    printf("%d\n", sizeof(&p + 1)); // 4/8 &p+1意思是先取出指针p的地址，再让它往后走一步，所以计算的仍旧是地址的大小
    printf("%d\n", sizeof(&p[0] + 1)); // 4/8 计算'b'的地址的大小
    return 0;
}

int main(){
    char* p = "abcdef";
    printf("%d\n", strlen(p)); // 6
    printf("%d\n", strlen(p + 1)); // 5
    printf("%d\n", strlen(*p)); // err
    printf("%d\n", strlen(p[0])); // err
    printf("%d\n", strlen(&p)); // 随机值 解释：&p指取出p的地址，那么p的地址可能是0x00131214，这个时候如果是小端存储那应该是这么存：14 12 13 00，如果使用strlen显然这里会得到结果为3，因为最后一个字符是00；而如果p的地址是0x12131415，按照小端存储则是：15 14 13 12，此时使用strlen就不知道会得到什么结果了，因为不知道什么时候遇到00
    printf("%d\n", strlen(&p + 1)); // 随机值 解释：先取出p的地址，再让它往后走一步，这个时候后面什么时候遇到00仍旧是不知道的
    printf("%d\n", strlen(&p[0] + 1)); // 5
    return 0;
}

int main(){
    int a[3][4] = {0};
    printf("%d\n", sizeof(a)); // 48
    printf("%d\n", sizeof(a[0][0])); // 4
    printf("%d\n", sizeof(a[0])); // 16 a[0]相当于第一行作为一维数组的数组名，sizeof(arr[0])把数组名单独放在sizeof()内，计算的是第一行的大小
    printf("%d\n", sizeof(a[0] + 1)); // 4/8 a[0]是第一行的数组名，数组名此时是首元素的地址，a[0]其实就是第一行第一个元素的地址，所以a[0]+1就是第一行第二个元素的地址  
    printf("%d\n", sizeof(*(a[0] + 1))); // 4 *(a[0] + 1)是第一行第二个元素
    printf("%d\n", sizeof(a + 1)); // 4 a是二维数组的数组名，没有sizeof(a)，也没有&(a)，所以a是首元素地址，而把二维数组看成一维数组时，二维数组的首元素是他的第一行，a就是第一行（首元素）的地址，那么a+1就是第二行的地址
    printf("%d\n", sizeof(*(a + 1))); // 16 sizeof(a[1]) == sizeof(*(a+1))计算的是第二行的大小
    printf("%d\n", sizeof(&a[0] + 1)); // 4/8 第二行的地址
    printf("%d\n", sizeof(*(&a[0] + 1))); // 16 计算第二行的大小
    printf("%d\n", sizeof(*a)); // 16 a是首元素地址（第一行地址），那么*a就是第一行，sizeof(*a)就是计算第一行的大小
    printf("%d\n", sizeof(a[3])); // 16 虽然a[3]越界了，但是放入sizeof()中的表达式是不会真实运算的，sizeof只是根据类型来判断传入的东西占多少字节大小的内存空间而已，a[3]是一个4个整型的一维数组，所以大小是16
    return 0;
}

struct Test{
    int Num;
    char* pcName;
    short sDate;
    char cha[2];
    short sBa[4];
}* p; // 这里的p其实就是一个struct Test*类型的全局的指针
// 假设p的值为0x100000，如下表达式的值分别是多少？
// 已知，结构体Test类型的变量大小是20个字节
int main(){
    p = (struct Test*)0x100000;
    printf("%p\n", p + 0x1); // 0x100014 结构体Test类型的变量大小是20个字节
    printf("%p\n", (unsigned long)p + 0x1); // 0x100001 转化成整型了，正常计算即可
    printf("%p\n", (unsigned int*)p + 0x1); // 0x100004 int型指针长度为4个字节
    return 0;
}

int main(){
    int a[4] = {1,2,3,4};
    int *ptr1 = (int*)(&a + 1);
    int *ptr2 = (int*)((int)a + 1);
    printf("%x,%x\n", ptr1[-1], *ptr2); // 0x4,0x02 00 00 00
    // 分析：首先ptr1应该比较好理解，&a+1之后强转成int*，指针指向数组a末尾的后面那个位置，然后ptr1[-1] == *(ptr1 - 1) 因此ptr1[-1]为数组a的最后一个元素，也就是4；然后来看ptr2，首先解释(int*)((int)a + 1); 先将a转成int型，此时a+1就是正常的加1，之后再将a+1的值转成int*，其实这就相当于指针往后走了一个字节（指针的最小步长单位是1字节），而数组a又是小端存储的，也就是说在内存中它是这么存的：01 00 00 00 02 00 00 00 03 00 00 00 04 00 00 00，那么原先ptr2解引用之后相当于拿出01 00 00 00这一段，而现在ptr2向后走了一个字节，此时再解引用就相当于拿出 00 00 00 02 这一段，由于是小端存储，所以其实就是这么一个十六进制数：02 00 00 00 。所以最后输出：0x4,0x02000000
    return 0;
}

int main(){
    int a[3][2] = {(0, 1), (2, 3), (4, 5)};
    int *p;
    p = a[0];
    printf("%d", p[0]); // 1 请看下图
    return 0;
}

int main(){
    int a[5][5];
    int (*p)[4];
    p = a;
    printf("%p,%d\n", &p[4][2] - &a[4][2], &p[4][2] - &a[4][2]); // 0xFF FF FF FC,-4 请看下图
    // 解释：p = a的时候首先p的类型是int(*)[4]，a是数组首元素也就是第一行，因此它的类型是int(*)[5]，然后我们来看a[4][2]和p[4][2]，a[4][2]其实很好理解，就是找到第五行的第三个元素，而p[4][2] == *(*(p + 4) + 2)，也就是说以4个为一行，找到第5行的第3个元素，其实就是a数组第4行第4个元素。此时以%d打印&p[4][2] - &a[4][2]就不难了，答案是-4，以%p打印的时候首先%p打印的是地址，地址没有负数，因此被打印的数就要当成一个无符号数，-4的补码不难得到，由于是无符号数所以打印的时候补码直接被当成源码打印出来，也就得到了0xfffffffc的结果
    return 0;
}

int main(){
    int aa[2][5] = {1,2,3,4,5,6,7,8,9,10};
    int* ptr1 = (int*)(&aa + 1); // 跳过整个数组，指向数组末尾元素的后面那个元素
    int* ptr2 = (int*)(*(aa + 1)); // *(aa + 1)马上想到aa[1]，就是说aa是首元素地址，也就是第一行地址，+1之后就是第二行地址，因此解引用之后其实就是第二行，那么ptr2其实指向的就是第二行的首元素
    printf("%d,%d\n", *(ptr1 - 1), *(ptr2 - 1)); // 由于ptr1、ptr2都被转成int*（其实ptr2都不用转，它自己就是int*类型，因为数组名表示首元素地址），所以输出为10，5
    return 0;
}

int main(){
    char* a[] = {"work", "at", "alibaba"};
    char** pa = a;
    pa++;
    printf("%s\n", *pa); // at
    return 0;
}

int main(){
    char* c[] = {"ENTER", "NEW", "POINT", "FIRST"};
    char** cp[] = {c+3, c+2, c+1, c};
    char*** cpp = cp;
    printf("%s\n", **++cpp); // POINT
    printf("%s\n", *--*++cpp + 3); // ER
    printf("%s\n", *cpp[-2] + 3); // ST
    printf("%s\n", cpp[-1][-1] + 1); // EW
    
    return 0;
}
// 内存分布图见下图

struct
{
    int a;
    char b;
    float c;
}x;
struct
{
    int a;
    char b;
    float c;
} *p1;
struct
{
    int a;
    char b;
    float c;
}a[10], *p2;

int main(){
    p1 = &x; // 非法的，会报警告 因为虽然上面第一个结构体和第二个结构体成员变量都一样，看似是同一个类型，但是编译器会将它们视为两个不同的类型。而不同的类型是做不了这个操作的（p1 = &x）
    return 0;
}

struct Node{
    int data;
    struct Node next;
};
// 可行吗？ 答案：不行！ 试想一下，如果可以的话sizeof(struct Node)将会是无穷大

struct Node{
    int data; 
    struct Node* next; //不存struct Node本身，而是存它的地址
}
// 可行吗？可以！

// 下面这种写法是错误的
typedef struct{ // 结构体标签省略了，说明这里是想重命名匿名结构体
    int data;
    Node* next; // 这里的Node到底是先重命名结构体为Node再使用Node这个名称然后创建结构体呢还是先创建这个结构体，再重命名结构体为Node，再使用Node这个名称呢？是会有歧义的，所以这样写不行而且这样写编译器会报错！
}Node;

// 所以建议就是在使用typedef的时候就不要省略结构体标签了
typedef struct Node{
    int data;
    struct Node* next; // 这里的struct也不要省略
}Node;

struct Node n1;

struct Node n1 = {0};

struct Point{
    int a;
    int b;
};
struct Point p1 = {0}; // 全局初始化
struct Node{
    int data;
    struct Point p;
    struct Node* next;
}n1 = {20, {5, 6}, NULL}; // 全局初始化

int main(){
    return 0;
}

struct S1{
    char c1; // 第一个成员变量直接放在该结构体变量在内存中开始定义的那个地址的偏移量为0的地址处
    // 后面的变量需要看对齐数
    int a; // 对齐数VS中默认为8，而a是int型，大小为4，两者取较小值为4，因此a放到该结构体变量在内存中开始定义的那个地址的偏移量为4的倍数的地址处（一看发现只需要偏移量为4而不需要偏移量为8、12、...）。此时跟上面的c1变量是隔了三个字节的内存空间（被浪费掉了）
    char c2; // 对齐数VS中默认为8，而c2是char型，大小为1，两者取较小值为1，因此c2放到该结构体变量在内存中开始定义的那个地址的偏移量为1的倍数的地址处，一看发现只需要放到变量a后面即可
}; // 最后结构体总大小为最大对齐数的整数倍（由于最大对齐数是4，因此只能取4、8、12、...）又因为上面这些成员变量消耗掉的内存空间大小为：4 + 4 + 1 = 9，所以只能取12（意味着最后三个字节也是被浪费的）

struct S1{
    char c1; // 第一个变量放到相对起始地址偏移量为0的地址处
    char c2; // 第二个变量对齐数是1，放到起始地址开始偏移量为1的倍数的地址处
    int a; // 第三个变量对齐数是4，放到起始地址开始偏移量为4的倍数的地址处
} // 最后由于上述变量耗费空间：1 + 1 + 2(浪费掉的空间) + 4 = 8，而8已经是4的倍数了，因此总大小就是8

struct S2{
    double d;
    char c;
    int i;
}; // 首先先算得结构体S2的大小为16
struct S3{
    char c; // 第一个变量放到相对起始地址偏移量为0的地址处
    struct S2 s2; // 嵌套的结构体对齐到自己的最大对齐数的整数倍处，所以先看结构体S2的最大对齐数，显然是8，那么变量s2的对齐数就是8和VS默认的8之间取最小值（如果是gcc的话由于gcc没有默认对齐数，所以直接就取8就行），其实就是8，那么它就应该放到相对起始地址偏移量为8的倍数的地址处，且占用16个字节
    double d; // 放到相对起始地址偏移量为8的倍数的地址处
}; // 上述变量占用空间：1 + 7（浪费掉的） + 16 + 8 = 32，再看上述变量最大对齐数是8，而32已经是8的倍数了，因此结构体S3的大小就是32

#pragma pack(4) // 设置默认对齐数为4
struct S1{
    char c;
    double i;
};
#pragma pack() // 取消设置的默认对齐数，还原为默认
int main(){
    printf("%d\n", sizeof(struct S1)); // 12
    return 0;
}

#include<stddef.h>
struct S{
    char c;
    int i;
    double d;
};
int main(){
    printf("%d\n", offsetof(struct S, c)); // 0
    printf("%d\n", offsetof(struct S, i)); // 4
    printf("%d\n", offsetof(struct S, d)); // 8
    return 0;
}

// 基本思想：由于在计算结构体成员偏移量的时候结构体可能未被实际创建，那么结构体成员变量也是未被实际创建的，所以没办法通过成员变量地址-结构体起始地址的方式来计算偏移量。
// 那么就应该换个思路，试想如果结构体起始地址是0，那么成员变量地址-0其实就是成员变量的偏移量了，也就是说如果结构体起始地址是0，成员变量的地址就是成员变量的偏移量
#define OFFSETOF(struct_name, member_name) (int)&(((struct_name*)0)->member_name)
struct S{
    char c1;
    int a;
    char c2;
};
int main(){
    printf("%d\n", OFFSETOF(struct S, c1));
    printf("%d\n", OFFSETOF(struct S, a));
    printf("%d\n", OFFSETOF(struct S, c2));
    return 0;
}

void Print(const struct S* ps);

struct S{
    char a : 3;
    char b : 4;
    char c : 5;
    char d : 4;
};
int main(){
    struct S s; // 首先开辟内存空间，由于位段的成员变量是char型，所以一次分配一个char型变量的空间，分配完a、b之后该char型变量空间还剩1bit，而c变量需要5bit，所以剩余的1bit被抛弃掉，重新再分配一个char型变量的空间去装c，装完c之后还剩3bit显然装不下d了，抛弃掉，重新再分配一个char型变量的空间去装d，最后剩余的4bit抛弃掉
    // 在装数据之前，先明确一点：申请一个char型变量空间（8bit），那么数据是从右往左放还是从左往右放呢？答案是在该编译器下是从右往左（上面也说了，位段涉及很多不确定因素，所以不跨平台，其实就体现在这里，不同编译器数据从右往左还是从左往右放是没有一个明确的标准的（C语言标准中根本没有定义这个标准），所以不同的编译器之间有可能是不一样的）
    s.a = 10; // a变量申请的空间是3bit，而10的二进制是：1010，截取010
    // a变量放入第一个char型变量的空间中：00000010
    s.b = 20; // b变量申请的空间是4bit，而20的二进制是：10100，截取0100
    // b变量放入第一个char型变量的空间中：00100010
    s.c = 3; // c申请的空间是5bit，而3的二进制是：101，所以前面补全变：00101
    // c放入第二个char型变量的空间中：00000101
    s.d = 4; // d申请的空间是4bit，而4的二进制是：100，所以前面补全变：0100
    // d放入第三个char型变量的空间中：00000100
    return 0;
}
// 所以该位段装入数据之后内存中存的就是：0010 0010 0000 0101 0000 0100（换成16进制也就是：2 2 0 3 0 4）

#define MAX_SIZE A+B
struct S{
    unsigned char a : 3;
    unsigned char b : 4;
    unsigned char c;
    unsigned char d : 1;
}; // 显然用了3个字节
int main(){
    int A = 2;
    int B = 3;
    // sizeof(struct S) * MAX_SIZE -> sizeof(struct S) * A+B ->sizeof(struct S) * 2+3->3 * 2+3
    printf("%d\n", sizeof(struct S) * MAX_SIZE); // 9
    return 0;
}

int main(){
    unsigned char puc[4];
    struct tagPIM{
        unsigned char ucPim1;
        unsigned char ucData0 : 1;
        unsigned char ucData1 : 2;
        unsigned char ucData2 : 3;
    }*pstPimData;
    pstPimData = (struct tagPIM*)puc;
    memset(puc, 0, 4); // 此时pstPimData指向内存：00000000 00000000 00000000 00000000 
    pstPimData->ucPim1 = 2; // 由于ucPim1占用一个字节，所以2直接从右往左放到第一个字节。此时pstPimData指向内存：00000010 00000000 00000000 00000000
    pstPimData->ucData0 = 3; // 由于ucData0占用1个bit，而3的二进制：0011，所以截1个bit，从右往左放到第二个字节。此时pstPimData指向内存：00000010 00000001 00000000 00000000
    pstPimData->ucData1 = 4; // 由于ucData1占用2个bit，而4的二进制：0100，所以截2个bit，从右往左放到第二个字节（为啥还是放第二个字节上面位段的内存分配机制已经解释很清楚了这里就不解释了）。此时pstPimData指向内存：00000010 00000001 00000000 00000000
    pstPimData->ucData2 = 5; // 由于ucData2占用3个bit，而5的二进制：0101，所以截3个bit，从右往左放到第二个字节（为啥还是放第二个字节上面位段的内存分配机制已经解释很清楚了这里就不解释了）。此时pstPimData指向内存：00000010 00101001 00000000 00000000
    printf("%02x %02x %02x %02x\n", puc[0], puc[1], puc[2], puc[3]); // 02 29 00 00 
    // %02x的意思是以16进制打印，并且只截取2位打印
    return 0;
}

// 枚举类型
enum Sex{
    // 枚举可能取值
    MALE, // 0
    FEMALE, // 1
    SECRET // 2
};
int main()[
    enum Sex s = FEMALE;
    printf("%d\n", s); // 1
    printf("%d %d %d\n", MALE, FEMALE, SECRET); // 0 1 2
    return 0;
]

enum Sex{
    MALE = 2,
    FEMALE = 4,
    SECRET = 8
};
int main(){
    enum Sex s = FEMALE;
    printf("%d\n", s); // 4
    printf("%d %d %d\n", MALE, FEMALE, SECRET); // 2 4 8
    return 0;
}

enum Sex{
    MALE = 2,
    FEMALE,
    SECRET = 8
};
int main(){
    enum Sex s = FEMALE;
    printf("%d\n", s); // 3
    printf("%d %d %d\n", MALE, FEMALE, SECRET); // 2 3 8
    return 0;
}

enum Sex{
    MALE = 2,
    FEMALE,
    SECRET
};
int main(){
    enum Sex s = FEMALE;
    printf("%d %d\n", s); // 3
    printf("%d %d %d\n", MALE, FEMALE, SECRET); // 2 3 4
    return 0;
}

enum Sex{
    MALE,
    FEMALE = 9,
    SECRET
};
int main(){
    enum Sex s = FEMALE;
    printf("%d %d\n", s); // 9
    printf("%d %d %d\n", MALE, FEMALE, SECRET); // 0 9 10
    return 0;
}

enum Sex{
    MALE,
    FEMALE,
    SECRET
};
int main(){
    enum Sex s = 2; // 右边是int型，左边是enum Sex型，两个东西类型都不一样，直接赋值是会有问题的
    return 0; 
}

enum Sex{
    MALE,
    FEMALE,
    SECRET
};
int main(){
    enum Sex s = MALE;
    printf("%d\n", sizeof(s)); // 4 因为MALE、FEMALE这些枚举的值其实就是0、1，是整型，所以枚举的大小是4字节
    return 0;
}

union Un{
    char c;
    int i;
};
int main(){
    union Un u;
    printf("%d\n", sizeof(u)); // 4
    printf("%p\n", &u); // 00F1F90C
    printf("%p\n", &(u.c)); // 00F1F90C
    printf("%p\n", &(u.i)); // 00F1F90C
    return 0;
}

int check_sys(){
    // union Un{
    //   char c;
    //   int i;
    // }u;
    // 或者可以写成匿名联合：
    union{
        char c;
        int i;
    }u;
    u.i = 1; // 先把成员变量i赋值为1，那么共用的那块空间就被赋值成了1，此时再看成员变量c的值就相当于截取了那块空间的第一个字符的值，巧妙的完成了大小端的判断
    // 返回1，表示小端
    // 返回0，表示大端
    return u.c;
}

union Un{
    int a;
    char arr[5];
};// 首先a是4字节，arr是5字节，所以明确一点，结构体Un大小一定大于等于5字节；然后来看最大对齐数，首先a是4字节，vs下的默认对齐数是8，4和8比取较小值4，因此a的对齐数就是4，然后看arr，arr是一个数组，数组的对齐数是根据数组元素的类型来计算的，这里arr中的元素的类型是char，因此arr的对齐数是1，所以我们可以得到联合体Un最大对齐数是4。现在我们已经找到了对于联合Un的大小的两个限定条件：1、是4的倍数；2、大于等于5。因此可以得出联合Un的大小为8

int main(){
    union{
        short k;
        char i[2];
    }*s, a;
    s = &a;
    s->i[0] = 0x39;
    s->i[1] = 0x38;
    printf("%x\n", a.k); // 由于测试机器是小端，因此低位放低地址，高位放高地址，显然i[1]（0x38）是低位，i[0]（0x39）是高位，因此0x38放在低地址，0x39放在高地址，因此打印出来是3839
    return 0;
}

struct Student stus[50];

int stu_num = 0;
printf("%s", "请输入学生人数：>");
scanf("%s", &stu_num);
struct Student stus[stu_num];

#include<stdlib.h>
#include<string.h>
#include<errno.h>
int main(){
    // 向内存申请10个整型的空间，并返回该内存空间的起始地址
    int* p = (int*)malloc(10 * sizeof(int));
    if(p == NULL){
        // 内存空间不够，开辟空间失败
        printf("%s\n", strerror(errno));
    }else{
        // 开辟内存成功
        // 注意此时开辟的内存里面放的都是一些随机的东西
    }
    // 当动态申请的空间不再使用的时候，就应该还给操作系统
    free(p); // 其实就算不free，程序生命周期结束的时候也会把申请的空间还回去，但是如果不free，这块内存空间就会一直被占用
    p = NULL; // free之后指针p指向的内存空间确实还回去了，但是指针p的值没改变，我们依然可以通过指针p找到那一块内存空间，找到它就有可能破坏它，那么这个时候指针p还是非常危险的，所以这个时候还需要再把指针p置为NULL
    return 0;
}

#include<stdlib.h>
#include<string.h>
#include<errno.h>
int main(){
    // 向内存申请10个整型的空间，并返回该内存空间的起始地址
    // int* p = (int*)malloc(10 * sizeof(int));
    int* p = (int*)calloc(10, sizeof(int));
    if(p == NULL){
        // 内存空间不够，开辟空间失败
        printf("%s\n", strerror(errno));
    }else{
        // 开辟内存成功
        // 注意此时开辟的内存里面放的东西已经全部初始化为0
    }
    // 当动态申请的空间不再使用的时候，就应该还给操作系统
    free(p); // 其实就算不free，程序生命周期结束的时候也会把申请的空间还回去，但是如果不free，这块内存空间就会一直被占用
    p = NULL; // free之后指针p指向的内存空间确实还回去了，但是指针p的值没改变，我们依然可以通过指针p找到那一块内存空间，找到它就有可能破坏它，那么这个时候指针p还是非常危险的，所以这个时候还需要再把指针p置为NULL
    return 0;
}

int main(){
    int* p = (int*)malloc(20);
    if(p == NULL){
        printf("%s\n", strerror(errno));
    }else{
        int i = 0;
        for(i = 0; i < 5; i++){
            *(p + i) = i; 
        }
    }
    // 假设在使用malloc开辟的20个字节空间的时候发现20个字节不能满足我们的使用了
    // 希望能有40个字节的空间
    // 这里就可以使用realloc来调整动态开辟的内存
    // 
    // realloc使用的注意事项：
    // 1.如果p指向的空间之后有足够的内存空间可以追加，则直接追加，后返回p
    // 2.如果p指向的空间之后没有足够的内存空间可以追加，则realloc函数会重新找一个新的内存区域
    //  开辟一块满足需求的空间，并且把原来内存中的数据拷贝回来，释放旧的内存空间，最后返回新开辟的内存空间地址
    // 3.如果我们这么写：p = realloc(p, INT_MAX);显然realloc会失败，返回NULL，此时就把p赋值成了NULL，导致在内存扩容失败的同时连原空间都找不到了，这是非常不好的。所以得用一个新的变量来接收realloc函数的返回值，如下：
    int* ptr = realloc(p, 40);
    if(ptr != NULL){
        // 追加成功，就把ptr赋值给p
        p = ptr;
        int i = 0;
        for(i = 0; i < 10; i++){
            printf("%d ", *(p + i));
        } // 打印结果：0 1 2 3 4 -842150451 -842150451 -842150451 -842150451 -842150451
    }
    // 最后还是得释放内存
    free(p);
    p = NULL;
    return 0;
}

int *p = (int*)realloc(NULL, 40); // 等价于malloc(40)

int main(){
    int* p = (int*)malloc(40);
    // 万一malloc失败了，p就被赋值为NULL
    *p = 0; // err
    int i = 0;
    for(i = 0; i < 10; i++){
        *(p + i) = i; // err
    }
    free(p);
    p = NULL;
    return 0;
}

int main(){
    int* p = (int*)malloc(5*sizeof(int));
    if(p == NULL){
        return 0;
    }else{
        int i = 0;
        for(i = 0; i < 10; i++){
            *(p + i) = i; // err
        }
    }
    free(p);
    p = NULL;
    return 0;
}

int main(){
    int a = 10; // a是在栈上的，并不是动态开辟的内存
    int* p = &a;
    *p = 20;
    free(p); // err
    p = NULL;
    return 0;
}

int main(){
    int* p = (int*)malloc(40);
    if(p == NULL){
        return 0;
    }
    int i = 0;
    for(i = 0; i < 10; i++){
        *p++ = i; // 这里指针p发生了变化
    }
    // 使用free释放动态开辟内存的一部分
    free(p);
    p = NULL;
    return 0;
} // 这段程序将会崩溃。如果要释放内存，必须从开辟的内存的起始位置开始释放，如果只释放了动态开辟内存的一部分（或者说上面的p指针发生了改变），程序将会崩溃

void GetMemory(char* p){
    p = (char*)malloc(100);
}
void Test(void){
    char* str = NULL;
    GetMemory(str);
    strcpy(str, "hello world");
    printf(str);
}
int main(){
    Test();
    return 0;
}
// 1.运行的代码程序会出现崩溃的现象，崩溃是在“strcpy(str, "hello world");”这一句代码，原因是str此时是NULL
// 2.程序存在内存泄漏的问题
//  str以值传递的形式给p，因此p是对str的一份拷贝，p是GetMemory函数的形参，只能函数内部有效，等GetMemory函数返回之后，动态开辟内存尚未释放，并且无法找到，会造成内存泄漏

// 返回栈空间的地址的问题
char* GetMemory(void){
    char p[] = "hello world"; // 函数结束后被销毁
    return p; // 返回局部变量p的首元素地址
}
void Test(void){
    char* str = NULL;
    str = GetMemory(); // 拿到了已经被销毁的元素的地址
    printf(str); // 非法访问内存，所以打印出来的是随机值
}
int main(){
    Test();
    return 0;
}

// 返回栈空间的地址的问题
int* test(){
    int a = 10;
    return &a;
}
int main(){
    int* p = test();
    *p = 20; // 非法访问内存
    return 0;
}

//// 但是如果是这样写：
int* test(){
    static int a = 10; // a变全局变量，函数结束之后也不会被销毁
    return &a;
}
int main(){
    int* p = test();
    *p = 20;
    return 0;
}// 上面这个代码是完全没有问题的

// 释放的空间再次被使用
void Test(void){
    char* str = (char*)malloc(100);
    strcpy(str, "hello");
    free(str); // free释放str指向的空间后，并不会把str置为NULL
    if(str != NULL){
        strcpy(str, "world"); // 非法访问内存
        printf(str);
    }
}
int main(){
    Test();
    return 0;
}

struct S{
    int n;
    int arr[]; // 未知大小的-柔性数组成员-数组的大小是可以调整的
};
// 或者
struct S{
    int n;
    int arr[0]; // 未知大小的-柔性数组成员-数组的大小是可以调整的
};// 这种写法跟上面那种写法是等价的，写上面那种写法编译器编不过去的时候可以写这种写法

struct S{
    int n;
    int arr[]; 
};
int main(){
    struct S s;
    printf("%d\n", sizeof(s)); // 4 我们发现它并没有包含柔性数组成员的大小
    return 0;
}

struct S{
    int n;
    int arr[]; // 柔性数组成员
};
int main(){
    struct S* ps = (struct S*)malloc(sizeof(struct S) + 5 * sizeof(int)); // 开辟一块内存空间，sizeof(struct S)为为非柔性数组成员开辟的空间的大小，5 * sizeof(int)为为柔性数组成员arr开辟的空间的大小，具体请看下图
    
    //// 开始使用该结构体
    ps->n = 100;
    int i = 0;
    for(i = 0; i < 5; i++){
        ps->arr[i] = i;
    }
    struct S* ptr = realloc(ps, 44);
    if(ptr != NULL){
        ps = ptr;
    }
    for(i = 5; i < 10; i++){
        ps->arr[i] = i;
    }
    for(i = 0; i < 10; i++){
        printf("%d\n", ps->arr[i]);
    }
    // 释放
    free(ps);
    ps = NULL;
    return 0;
}

struct S{
    int n;
    int* arr;
};
int main(){
    struct S* ps = (struct S*)malloc(sizeof(struct S));
    // 这里是把结构体开辟在堆上，所以用malloc去开辟结构体的内存空间，当然也可以将结构体开辟在栈上，只需要这么写：
    // struct S s;
    ps->arr = (int*)malloc(5 * sizeof(int));
    // 开始使用结构体S
    int i = 0;
    for(i = 0; i < 5; i++){
        ps->arr[i] = i;
    }
    for(i = 0; i < 5; i++){
        printf("%d ", ps->arr[i]);
    }
	int* ptr = (int*)realloc(ps->arr, 10 * sizeof(int));
    if(ptr != NULL){
        ps->arr = ptr;
    }
    for(i = 5; i < 10; i++){
        ps->arr[i] = i;
    }
    for(i = 0; i < 10; i++){
        printf("%d ", ps->arr[i]);
    }
    // 释放空间
    free(ps->arr);
    ps->arr = NULL;
    free(ps);
    ps = NULL;
    return 0;
}

FILE* pf; // 文件指针变量

FILE* fopen(const char* filename, const char* mode);
int fclose(FILE* stream);

int main(){
    // 打开文件
    // 绝对路径写法
    fopen("c:\\User\\Administrator\\test.txt", "r");
    // 相对路径写法
    fopen("test.txt", "r");
    // 相对路径还可以这么写
    fopen("../test.txt", "r");
    return 0;
}

int main(){
    FILE* pf = fopen("test.txt", "r");
    if(pf == NULL){
        // 说明打开文件失败，此时用于维护该文件的相关信息的FILE类型的结构体是不会被创建的，而且fopen返回的是NULL
        return 0;
    }
    // 打开成功
    // 读文件
    // 关闭文件（释放资源）
    fclose(pf);
    // 因为fclose是值传递，在释放完资源之后是不会改变指针pf的，因此还需要把指针pf置NULL
    pf = NULL;
    return 0;
}

// 写
#include<string.h>
#include<stdio.h>
#include<errno.h>
int main(){
    FILE* pf;
    pf = fopen("test.txt", "w");
    if(pf != NULL){
        // 写文件
        fputs("hello world", pf);
        fputs("hello\n", pf);
        fputs("world", pf);
        fputc('b', pf);
        fputc('a', pf);
        fclose(pf);
        pf = NULL;
    }else{
        printf("%s\n", strerror(errno));
    }
    return 0;
}

// 读 fgetc
#include<string.h>
#include<stdio.h>
#include<errno.h>
int main(){
    FILE* pf;
    pf = fopen("test.txt", "r");
    if(pf != NULL){
        // 读文件
        // 这里我们读两个字符
        printf("%c", fgetc(pf));
        printf("%c", fgetc(pf));
        fclose(pf);
        pf = NULL;
    }else{
        printf("%s\n", strerror(errno));
    }
    return 0;
}

// 读 fgets
// char* fgets(char* string, int n, FILE* stream);
#include<string.h>
#include<stdio.h>
#include<errno.h>
int main(){
    char buf[1024] = {0};
    FILE* pf = fopen("test.txt", "r");
    if(pf != NULL){
        fgets(buf, 1024, pf);
        // puts(buf); // puts()打印完之后会自动换行，如果打印的东西本身就有换行，那打印完之后它也会再换一行
        printf("%s", buf);
        fgets(buf, 1024, pf);
        // puts(buf); // puts()打印完之后会自动换行，如果打印的东西本身就有换行，那打印完之后它也会再换一行
        printf("%s", buf);
        fclose(pf);
        pf = NULL;
    }else{
        printf("%s\n", strerror(errno));
    }
    return 0;
}

// 从键盘读取一行文本信息并显示到控制台
int main(){
    char buf[1024] = {0};
    fgets(buf, 1024, stdin); // 从标准输入流读取
    fputs(buf, stdout); // 输出到标准输出流
    // 上面两行等价于下面两行：
    // gets(buf);
    // puts(buf);
    return 0;
}

// fprintf
// int fprintf(FILE* stream, const char* format[, argument]...);
#include<stdio.h>
struct S{
    int n;
    float score;
    char arr[10];
};
int main(){
    struct S s = {100, 3.14f, "bit"};
    FILE* pf = fopen("test.txt", "w");
    if(pf == NULL){
        return 0;
    }
    // 格式化的形式写文件
    fprintf(pf, "%d %f %s", s.n, s.score, s.arr);
    fclose(pf);
    pf = NULL;
    return 0;
}

// fscanf
// int fscanf(FILE* stream, const char* format[, argument]...);
#include<stdio.h>
struct S{
    int n;
    float score;
    char arr[10];
};
int main(){
    struct S s = {100, 3.14f, "bit"};
    FILE* pf = fopen("test.txt", "r");
    if(pf == NULL){
        return 0;
    }
    // 格式化的输入数据
    fscanf(pf, "%d %f %s", &(s.n), &(s.score), s.arr);
    printf("%d %f %s\n", s.n, s.score, s.arr);
    fclose(pf);
    pf = NULL;
    return 0;
}