1.内存和地址
在讲内存和地址之前，我们想有个生活中的案例： 假设有⼀栋宿舍楼，把你放在楼里，楼上有100个房间，但是房间没有编号，你的⼀个朋友来找你玩， 如果想找到你，就得挨个房子去找，这样效率很低，但是我们如果根据楼层和楼层的房间的情况，给每个房间编上号，如：201，202，203等等。有了房间号，如果你的朋友得到房间号，就可以快速的找房间，找到你。
如果把上面的例子对照到计算中，计算机上CPU（中央处理器）在处理数据的时候，需要的数据是在内存中读取的，处理后的数 据也会放回内存中，计算机其实也是把内存划分为⼀个个的内存单元，每个内存单元的大小取1个字节。其中，每个内存单元，相当于⼀个学生宿舍，⼀ 个人字节空间里面能放8个比特位，每个内存单元也都有⼀个编号（这个编号就相当 于宿舍房间的门牌号），有了这个内存单元的编 号，CPU就可以快速找到⼀个内存空间。生活中我们把门牌号也叫地址，在计算机中我们 把内存单元的编号也称为地址。C语言中给地址起 了新的名字叫：指针。 所以我们可以理解为： 内存单元的编号==地址==指针
2.指针变量和地址
2.1取地址操作符（&）
在C语言中创建变量其实就是向内存申请空间，假如我们创建一个整形变量int a = 10，该代码就会向内存申请4个字节，用于存放整数10，每个字节都有一个地址。
我们通过取地址操作符&就可以得到a的地址，&a取出的是a所占4个字节中地址较小的地址。
#include <stdio.h>
int main()
{
int a = 10;
printf("%p", &a);//0000004F858FF6C4
return 0;
}2.2指针变量和解引用操作符
（1）指针变量
我们通过取地址操作符(&)拿到的地址是⼀个数值，比如：0x006FFD70，这个数值有时候也是需要存储起来，方便后期再使用的，那我们把这样的地址值存放在哪里呢？答案是：指针变量中。
比如：
#include <stdio.h>
int main()
{
//指针 - 地址
//指针变量 - 存放地址的变量
int a = 10;
int* p = &a; //取出a的地址并存放在指针变量p中
return 0;
}指针变量也是⼀种变量，这种变量就是用来存放地址的，存放在指针变量中的值都会理解为地址。
int a = 10; //指针变量的类型是int *
int* p = &a; //*说明p是指针变量，
//而int是在说明是在说明p所指向的是int类型的对象
（2）解引用操作符（*）（间接访问操作符）
我们只要拿到了地址（指针），就可以通过地址（指针）找到地址（指针） 指向的对象，这⾥必须学习⼀个操作符叫解引⽤操作符(*)。
#include <stdio.h>
int main()
{
int a = 10;
int* p = &a;
printf("%d\n" ,* p);//10
*p = 0;
//*&a = 0；//取出地址再解引用，其实*&就相互抵消了
printf("%d", *p);//0
return 0;
}p中存放的是a的地址，而*p的意思就是p中存放的地址，找到指向的空间，*p其实就是a变量了。
（3）指针变量的大小
#include <stdio.h>
int main()
{
//指针变量的大小取决于地址的大小
//32位平台下，地址是32个比特位（4个字节）
//64位平台下，地址是64个bit位（8个字节）
printf("%zd\n", sizeof(char *));
printf("%zd\n", sizeof(short *));
printf("%zd\n", sizeof(int *));
printf("%zd\n", sizeof(double *));
//返回值都是8
return 0;
}注意指针变量的大小和类型是无关的，只要指针类型的变量，在相同的平台下，大小都是相同的。
3.指针变量类型的意义
3.1指针的解引用
//代码1
int main()
{
int a = 0x11223344;
int* p = &a;
p = 0;
return 0;
}
//代码2
int main()
{
int a = 0x11223344;
char* p = (char *)&a;
p = 0;
return 0;
}调试我们可以看到，代码1会将n的4个字节全部改为0，但是代码2只是将n的第⼀个字节改为0。 结论：指针的类型决定了，对指针解引用的时候有多大的权限（⼀次能操作几个字节）。 char* 的指针解引用就只能访问⼀个字节，而nt* 的指针的解引⽤就能访问四个字节。
3.2指针+-整数
#include <stdio.h>
int main()
{
int n = 10;
int* pc = &n;
char* pi = (char *)&n; //写成char * pi = &n;编译器会给出一个警告
printf("%p\n", &n);
printf("%p\n", pc);
printf("%p\n", pc + 1);
printf("%p\n", pi);
printf("%p\n", pi + 1);
return 0;
} 代码运行结果：
我们可以看出，char* 类型的指针变量+1跳过1个字节，这就是指针变量的类型差异带来的变化。int* 类型的指针变量+1跳过了4个字节。
结论：指针的类型决定了指针向前或者向后走⼀步有多大（距离）。
3.3void*指针
在指针类型中有⼀种特殊的类型是 void* 类型的，可以理解为无具体类型的指针（或者叫泛型指 针），这种类型的指针可以用来接受任意类型地址。但是也有局限性，行指针的+-整数和解引⽤的运算。
int main()
{
int a = 0x11223344;
char* p = &a;
*p = 0;
return 0;
}在上面的代码中，将⼀个int类型的变量的地址赋值给⼀个char*类型的指针变量。编译器给出了⼀个警告（如下图），是因为类型不兼容。而使用void*类型就不会有这样的问题。
使用void类型的指针接收地址：
int main()
{
int a = 10;
void* pc = &a;
void* pi = &a;
*pc = 10;
*pi = 0;
return 0;
}
⼀般void* 类型的指针是使用在函数参数的部分，用来接收不同类型数据的地址，这样的设计可以 实现泛型编程的效果。
4.const修饰指针
4.1const修饰变量
const可以给变量加上限制，使其不能被修改
int main()
{
const int n = 10;
n = 20;
return 0;
}上述代码中n是不能被修改的，其实n本质是变量，只不过被const修饰后，在语法上加了限制，只要我们在代码中对n进行修改，就不符合语法规则，就报错，致使没法直接修改n。
但是如果我们绕过n，使用n的地址，去修改n就能做到了，虽然这样做是在打破语法规则。
#include <stdio.h>
int main()
{
const int n = 10;
int* p = &n;
printf("%d\n", n); //10
*p = 20;
printf("%d\n", n); //20
printf("%d\n", *p); //20
return 0;
}我们可以看到这里⼀个确实修改了，但是我们还是要思考⼀下，为什么n要被const修饰呢？就是为了 不能被修改，如果p拿到n的地址就能修改n，这样就打破了const的限制，这是不合理的，所以应该让 p拿到n的地址也不能修改n，那接下来怎么做呢？
4.2const修饰指针变量
#include <stdio.h>
void test1()
{
int n = 10;
int m = 20;
int* p = &n;
*p = 30;//可以，*p=30
p = &m;//可以，*p为20
}
void test2()
{
int n = 10;
int m = 20;
int const* p = &n;
*p = 30;//不可以，会报错，指针变量指向的内容不可以改变
p = &m;//可以，指针变量本身的内容可以改变
}
void test1()
{
int n = 10;
int m = 20;
int* const p = &n;
*p = 30;//可以，指针变量指向的内容可以改变
p = &m;//不可以，指针变量本身的内容不能改变
}
void test4()
{
int n = 10;
int m = 20;
int const* const p = &n;
*p = 30;//不可以
p = &m;//不可以
}
int main()
{
//测试无const修饰的情况
test1();
//测试const在*左边的情况
test2();
//测试const在*右边的情况
test3();
//测试*两边都有*的情况
test4();
return 0;
}结论：const修饰指针变量的时候
• const如果放在*的左边，修饰的是指针指向的内容，保证指针指向的内容不能通过指针来改变。 但是指针变量本身的内容可变。
• const如果放在*的右边，修饰的是指针变量本身，保证了指针变量的内容不能修改，但是指针指 向的内容，可以通过指针改变。
5.指针运算
指针的基本运算有三种，分别是： 指针+-整数 ，指针-指针 ，指针的关系运算
（1）指针+-整数
#include <stdio.h>
int main()
{
int arr[10] = {1,2,3,4,5,6,7,8,9,10};
int* p = &arr[0];
int i = 0;
int sz = sizeof(arr) / sizeof(arr[0]);
for (i = 0; i < sz; i++)
{ //*p指的是数组的第一个元素
printf("%d ", *(p + i));//输出数组
}
return 0;
}（2）指针-指针
指针1 + 整数 = 指针2 指针2-指针1=整数
指针 - 指针得到值的绝对值是两个指针之间的元素个数
#include <stdio.h>
int main()
{
int arr[10] = { 0 };
printf("%d\n", &arr[9] - &arr[0]);//9
printf("%d\n", &arr[0] - &arr[9]);//-9
return 0;
}
(3)指针的关系运算
int main()
{
int arr[10] = { 0,1,2,3,4,5,6,7,8,9 };
int* p = &arr;
int i = 0;
int sz = sizeof(arr) / sizeof(arr[0]);
while (p < arr + sz)
{
printf("%d ", *p);//0 1 2 3 4 5 6 7 8 9
p++;
}
return 0;
}6.野指针
概念：野指针就是指针指向的位置是不可知的（随机的、不正确的、没有明确限制的）
6.1野指针成因
（1）指针未初始化
#include <stdio.h>
int main()
{
int* p;//局部变量指针未初始化，默认为随机值
*p = 20;
return 0;
}
(2)指针越界访问
#include <stdio.h>
int main()
{
int arr[5] = { 1,2,3,4,5 };
int* p = arr;
int i = 0;
for (i = 0; i <= 5; i++)//当指针指向超出数组arr的范围时，p就是野指针
{
printf("%d ", *p);
p++;
}
return 0;
}（3）指针指向的空间释放
#include <stdio.h>
int* test()
{
int n = 100;
return &n;
}
int main()
{
int* p = test();//返回局部变量的地址不确定
printf("%d\n", *p);
return 0;
}6.2如何规避成为野指针
（1）指针初始化
（2）小心指针越界
（3）避免返回局部变量的地址
（4）指针变量不在使用时，及时设置NuLL，指针使用前检查有效性
7.assert断言
assert.h 头文件定义了宏assert()，用于在运行时确保程序符合指定条件，如果不符合，就报错终止运行。这个宏常常被称为“断言”。assert()宏接受⼀个表达式作为参数。如果该表达式为真（返回值非零）， 任何作用，程序继续运行。如果该表达式为假（返回值为零）， assert() 就会报错，在标准错误stderr中写入⼀条错误信息，显示没有通过的表达式，以及包含这个表达式的文件名和行号。assert() 的使用对程序员是非常友好的，使⽤ assert() 有几个好处：它不仅能自动标识文件和出问题的行号，还有⼀种无需更改代码就能开启或关闭 assert() 的机制。如果已经确认程序没有问 题，不需要再做断言，就在#include语句的前面，定义⼀个宏NDBUG 。然后，重新编译程序，编译器就会禁⽤⽂件中所有的 assert() 语句。如果程序⼜出现问题，可以移除这条 #define NDBUG 指令（或者把它注释掉），再次编译，这样就重新启⽤了 比特就业课 assert() 语 句。assert() 的缺点是，因为引入了额外的检查，增加了程序的运行时间。 ⼀般我们可以在 Debug 中使用，在Release 版本中选择禁用 assert 就行，在 vs这样的集成开发环境中，，在 Release 版本中，直接就是优化掉了。这样在debug版本写有利于程序员排查问题，在 Release 版本不影响用户使用时程序的效率。