一：void关键字
问题：void能否定义变量？
从图中不难发现，void定义x出错，可原因是什么呢？
定义变量的本质：开辟空间
而void作为空类型，理论上是不应该开辟空间的，即使开了空间，也仅仅作为一个占位符看待
所以，既然无法开辟空间，那么也就无法作为正常变量使用，既然无法使用，编译器干脆不让他定义变量。
void的大小在不同编译器下是不一样的
在vs2013中，sizeof(void)=0
在Linux中，sizeof(void)=1（但编译器依旧理解成，无法定义变量）
void本身就被编译器解释为空类型，强制的不允许定义变量。
void修饰函数返回值：
看代码：
#include<stdio.h> void test() { printf("hello test\n"); return 1; } int main() { test(); return 0; }
但是当我们去掉void返回值的时候再试试：
#include<stdio.h> test() { printf("hello test\n"); return 1; } int main() { int a = test(); // hello test printf("%d\n", a); // 1 return 0; }
我们发现编译器可以正常运行没有报错，由此得到以下结论：
//如果自定义函数，或者库函数不需要返回值，那么就可以写成void
//那么问题来了，可以不写吗？不可以，自定义函数的默认返回值是int(这个上述验证)
//所以，没有返回值，如果不写void，会让阅读你代码的人产生误解：他是忘了写，还是想默认int？
//结论：void作为函数返回值，代表不需要，这里是一个"占位符"的概念,是告知编译器和给阅读源代码的工程师看的。
void修饰函数参数：
看代码：
#include <stdio.h> int test1() //函数默认不需要参数 { return 1; } int test2(void) //明确函数不需要参数 { return 1; } int main() { //test1的形参列表为空，可不可以给它传参呢？ test1(1, 2, 3, 4); //依旧传入参数，编译器不会告警或者报错 test2(1, 2, 3, 4); //依旧传入参数，编译器会告警(vs)或者报错(gcc) return 0; }
总结：
结论：如果一个函数没有参数，将参数列表设置成void，是一个不错的习惯，因为可以将错误明确提前发现
另外，阅读你代码的人，也一眼看出，不需要参数。相当于"自解释"。
void充当函数的形参列表，告知用户or编译器，该函数不需要传参
void指针：
void不能定义变量，那么void*呢？
#include<stdio.h> int main() { void* p = NULL; return 0; }
这里编译器并没有报错，为什么void*可以呢？
因为void*是指针，是指针，空间大小就能明确出来
只要是指针，在32位就占4个字节，在64位就占8个字节。
void* 能够接受任意指针类型：&& void*可以接受任意指针类型：
#include<stdio.h> int main() { void* p = NULL; double* x = NULL; int* y = NULL; x = p; y = p; return 0; }
此代码块运行编译器没有报错。
x=p和y=p相当于把p指针变量的值赋给x和y,而x的类型是double*,y的类型是int*，p的类型是void*，等号左右两边类型不一样。
结论：void*可以被任何指针类型接受
当我们把x=p和y=p调换位置呢。
#include<stdio.h> int main() { void* p = NULL; double* x = NULL; int* y = NULL; p = x; p = y; return 0; }
编译器依旧没有报错。
结论：void*可以接受任意指针类型（常用）
void * 定义的指针变量可以进行运算操作吗？
#include<stdio.h> int main() { //void* p = NULL; int* p = NULL; p++; p--; // 对于整型指针是没有问题的 //而void*是空类型，在vs大小为0，而使用p++或--需要明确大小，故不行 return 0; }
// 对于整型指针是没有问题的
//而void*是空类型，在vs大小为0，而使用p++或--需要明确大小，故不行
void*可以直接解引用吗？
#include<stdio.h> int main() { // void* p = NULL; // *p; // err int a = 10; void* p = (void*)&a; // *p; // err *p = 20; // err return 0; }
原因：
p是void*指针类型，那么解引用*p它指向的目标就是void,而其空间大小无法得知
结论：void*不能直接解引用
二：return关键字
看代码：
#include<stdio.h> char* show() { char str[] = "helloworld"; return str; } int main() { char* s = show(); printf("%s\n", s); return 0; }
运行起来确是一串乱码 ，为什么呢？
此时在函数内定义的char str[] = "hello bit";数组是在栈上开辟的空间，它本质上是一份临时空间，函数调用的时候就在栈上开辟空间，函数调用完毕，栈结构，临时变量，数据就会被释放掉，所以打印乱码。
C语言有字符串但没有字符串类型
计算机如何删除数据呢？
//计算机中，释放空间是否真的要将我们的数据全部清0/1 ？
//计算机中清空数据，只要设置该数据无效即可
重新分析下上述的代码：
show函数是函数调用，调用时就要开辟空间，在这块空间中要开辟一块数组空间，而这块空间是在哪开辟的呢？接下来需要回顾下曾经讲过的内容。地址空间划分有如下几块：
调用函数，形成栈帧，函数返回，释放栈帧，但是数据并没有被清空，仅仅表明这块空间是可被覆盖的，printf也是函数，调用printf形成栈帧，返回printf释放栈帧，形成新的栈帧就要覆盖原先老的栈帧，所以helloworld字符串便不存在
//为什么临时变量具有临时性！
//栈帧结构在函数调用完毕，需要被释放
#include<stdio.h> int GetData() { int x = 0x11223344; printf("run get data!\n"); return x; } int main() { int y = GetData(); printf("ret:%x\n", y); return 0; }
既然x是函数定义的变量，具有临时性，那么这个临时变量在函数退出的时候，应该被释放,但为什么还能正常打印呢？
通过查看汇编可以看到，对于一般内置类型，寄存器eax可以充当返回值的临时空间
函数的返回值，通过寄存器的方式，返回给函数调用方！
三：const关键字
const修饰的变量是不可直接被修改！！！
#include<stdio.h> int main() { const int a = 10; // 等价于： int const a = 10; a = 20; // err return 0; }
但是可以通过指针的方式间接修改！！！
那const修饰变量，意义何在？
1. 让编译器进行直接修改式检查
2. 告诉其他程序员(正在改你代码或者阅读你代码的)这个变量后面不要改哦。也属于一种“自描述”含义
const修饰的变量，可以作为数组定义的一部分吗？
#include<stdio.h> int main() { const int n = 100; int arr[n]; // err 编译器报错 return 0; }
//在vs2013(标准C)下直接报错了，但是在gcc(GNU扩展)下，可以，主要是不同编译器对C语言的标准不同。
//但我们一切向标准看齐，不可以。
const修饰数组：
#include<stdio.h> int main() { const int arr[] = { 1,2,3,4,5 }; arr[0] = 0; //err arr[1] = 0; //err arr[2] = 0; //err arr[3] = 0; //err return 0; }
编译器报错，const修饰数组的话，代表的是数组的每一个元素都必须是不可被修改的，或者是只读数组
const修饰指针：
看代码：先总体了解下：
#include<stdio.h> int main() { int a = 10; int* p = &a; *p = 100; // *p=100对p进行解引用，代表的是p所指向的目标，所以*p就是a，换句话说是把a的值改为100 p = 100; // p=100,p本身也是一个变量，本来p指向a变量的，现在p指向地址为100的一个变量 return 0; }
// *p=100对p进行解引用，代表的是p所指向的目标，所以*p就是a，换句话说是把a的值改为100
// p=100,p本身也是一个变量，本来p指向a变量的，现在p指向地址为100的一个变量
情形一：
#include<stdio.h> int main() { int a = 10; const int* p = &a; //p指向的变量不可直接被修改 *p = 100; // err p = 100; return 0; }
此时，*p=100；编译器报错，理由如下：
// 此时的const修饰的是*p,不是p，也就是说不是p无法改变，而是p指向的内容无法改变
// 此时如果对p进行解引用，那么这个值是不能被修改的，换言之p指向的变量不可被修改，p无法被解引用后充当左值
// 所以p=100不会报错
情形二：
{ int a = 10; int const * p = &a； //p指向的变量不可直接被修改 *p = 100; // err p = 100; return 0; }
此情况和上述第一种一样，const修饰的都是*p而不是p，只不过将const挪位到int的右边，但不影响结果，理由和情形一相同。
情形三：
#include<stdio.h> int main() { int a = 10; int* const p = &a; //p的内容不可直接被修改，p指向不能改 *p = 100; p = 100; // err return 0; }
int* const p = &a; //此时的const在*的右侧，在p的左侧，则这个const修饰的是p变量，这样写和const int a = 10;没有差别，则就表明p的值不可直接被修改，p指向不能改
*p = 100; // 但是可以间接修改，此时*p指向a，a可以被修改，*p=100;是没有问题的
而p=100;就是错的。
情形四：
#include<stdio.h> int main() { int a = 10; const int* const p = &a; *p = 100; // err p = 100; // err return 0; }
const int* const p = &a; //最左边的const指向*，代表p指向的不可以直接被修改，而离p最近的const修饰的是p，代表的是p的指向不能被修改
所以*p=100和p=100都是错的。
const修饰函数参数：
#include<stdio.h> void show(const int* _p) { printf("value:%d\n", _p); } int main() { int a = 10; int* p = &a; show(p); return 0; }
一般我们在设计的时候，因为show函数从设计角度本质就是打印，内部的打印就不会对传的参数进行修改，为了写出严谨的代码，应该在传参的时候带上const,代表的是此时_p指针变量所指向的内容不可改，也就是对应的a是不可改的
const修饰函数返回值：
代码解释：
#include<stdio.h> //告诉编译器，告诉函数调用者，不要试图通过指针修改返回值指向的内容 const int* GetVal() { static int a = 10; return &a; } int main() { // int *p = test(); //有告警 const int* p = GetVal(); //需要用const int*类型接受 *p=200; //err //这样，【在语法/语义上】，限制了，不能直接修改函数的返回值 return 0; } //一般内置类型返回，加const无意义。
