今天我们进入指针的复习了.这部分有很多知识,话不多说,让我们进入指针的世界吧.
内存和地址
要想学指针就不能不学内存和地址.
内存
其中，每个内存单元，相当于⼀个学⽣宿舍，⼀ 个字节空间⾥⾯能放8个⽐特位，就好⽐同学们 住的⼋⼈间，每个⼈是⼀个⽐特位。 每个内存单元也都有⼀个编号（这个编号就相当于宿舍房间的⻔牌号），有了这个内存单元的编号，CPU就可以快速找到⼀个内存空间.在计算机中我们把内存单元的编号也称为地址。C语⾔中给地址起 了新的名字叫：指针.
所以我们可以理解为： 内存单元的编号 == 地址 == 指针
究竟该如何理解编址
指针变量和地址
取地址操作符（&）
在C语⾔中创建变量其实就是向内存申请空间,下图为例子:
我们如何能得到a的地址呢？这里就要用到取地址操作符了.(打印地址需要用%p)例子为下面代码:
#include<stdio.h>
int main()
{
int a = 10;
printf("%p", &a);
return 0;
}注:&a取出的是a所占4个字节中地址较⼩的字节的地址。虽然整型变量占⽤4个字节，我们只要知道了第⼀个字节地址，就可以顺藤摸⽠访问到4个字节的数据.
指针变量和解引用操作符（*）
指针变量
我们通过取地址操作符取到地址,我们需要把这个地址存到指针变量中.指针变量也是⼀种变量，这种变量就是⽤来存放地址的，存放在指针变量中的值都会理解为地址.
int main()
{
int a = 10;
int* p = &a;
printf("%p\n", p);
return 0;
}如何拆解指针类型
我们看到p的类型是 int* ，我们该如何理解指针的类型呢?
这⾥p左边写的是 int* ， * 是在说明pa是指针变量，⽽前⾯的 int 是在说明pa指向的是整型(int) 类型的对象.同样的char的地址就会放入char*的指针变量中.
解引用操作符
我们拿到地址是为了使用,我们只要拿到了地址（指针）,就可以通过地址（指针）找到地址（指针） 指向的对象，这⾥需要的就是解引⽤操作符(*) .
int main()
{
int a = 10;
int* p = &a;
printf("%p\n", p);
printf("%d", a);
*p = 0;
printf("%d", a);
return 0;
}在上面的代码中,*p的意思就是通过pa中存放的地址，找到指向的空间， *p其实就是a变量了；所以*p = 0，这个操作符是把a改成了0.
指针变量的大小
根据前面的内容,32位机器假设有32根地址总线，每根地址线出来的电信号转换成数字信号后 是1或者0，那我们把32根地址线产⽣的2进制序列当做⼀个地址，那么⼀个地址就是32个bit位，需要4 个字节才能存储。 如果指针变量是⽤来存放地址的，那么指针变的⼤⼩就得是4个字节的空间才可以。 同理64位机器，有64根地址线，⼀个地址就是64个⼆进制位组成的⼆进制序列，存储起来就需要 8个字节的空间，指针变的大小就是8个字节.
//sizeof的返回值是size_t,打印最好用%zd来打印
int main()
{
printf("%zd\n", sizeof(char*));
printf("%zd\n", sizeof(short*));
printf("%zd\n", sizeof(int*));
printf("%zd\n", sizeof(double*));
return 0;
}
输出结果:
结论：
32位平台下地址是32个bit位，指针变量大小是4个字节
64位平台下地址是64个bit位，指针变量大小是8个字节
注意:指针变量的大小和类型是无关的,只要指针类型的变量,在相同的平台下,大小都是相同的.
指针变量类型的意义
既然所有指针的大小在同一平台下都是一样的,那么为什么要各种各样的指针类型呢?
指针的解引用
看下面两端代码,并且在执行时用调试来看他们的内存空间的变化.
调试我们可以看到,代码1会将n的4个字节全部改为0,但是代码2只是将n的第1个字节改为0.
结论：指针的类型决定了，对指针解引⽤的时候有多⼤的权限（⼀次能操作⼏个字节).(char* 的指针解引⽤就只能访问⼀个字节，⽽ int* 的指针的解引⽤就能访问四个字节).
指针+-整数
先看一下下面的代码:
int main()
{
int a = 10;
int* p1 = &a;
char* p2 = &a;
printf("%p %p\n", p1, p2);
p1 += 1; //p1加整数
p2 += 1; //p2加整数
printf("%p %p\n", p1, p2);
return 0;
}结果如下,可以看到int*的指针加1向后走了4个字节,而char*只走了1个字节.
结论：指针的类型决定了指针向前或者向后⾛⼀步有多⼤（距离）.
void* 指针
在指针类型中有⼀种特殊的类型是 void* 类型的，可以理解为⽆具体类型的指针（或者叫泛型指针），这种类型的指针可以⽤来接受任意类型地址.但是 void* 类型的指针不能直接进⾏指针的+-整数和解引⽤的运算.
int main()
{
int a = 10;
char b = 'n';
void* p1 = &a;
void* p2 = &b;
printf("%p %p", p1, p2);
//err
//*p1=0;
//p2++;
return 0;
}⼀般 void* 类型的指针是使⽤在函数参数的部分，⽤来接收不同类型数据的地址，这样的设计可以 实现泛型编程的效果.在之后的复习中会了解到.
const修饰指针
const修饰变量
变量是可以修改的，如果把变量的地址交给⼀个指针变量，通过指针变量的也可以修改这个变量。 但是如果我们希望⼀个变量加上⼀些限制，不能被修改，这就需要到const了.(例如下面的变量b.)
int main()
{
//变量可以修改,指针也可以间接修改变量
int a = 10;
printf("%d\n", a);
int* pa = &a;
*pa = 0;
printf("%d\n", a);
//这里b是不可以修改的
const int b = 10;
//b = 0; //err
//如果像下面的话,就意味着可以通过p2去改变b的值了,这是不合理的
//int* pb1 = &b;
//*pb1 = 0; 这里不会报错并且会改变b的值
//所以这里一定要用const来修饰指针
const int* pb2 = &b;
//*pb2 = 0; //err
return 0;
}const修饰指针变量
在上面的代码中我就用了const来修饰指针,下面让我们来看下下面的代码更加深入的学习.
void test1()
{
int n = 10;
int m = 20;
int* p = &n;
*p = 20;//ok?
p = &m; //ok?
}
void test2()
{
int n = 10;
int m = 20;
const int* p = &n;
//*p = 20; //ok?no const在*前修饰*p不可以通过指针改变指针指向的变量
p = &m; //ok?
}
void test3()
{
int n = 10;
int m = 20;
int* const p = &n;
*p = 20; //ok?
//p = &m; //ok?no const在*后修饰p不可以改变p的指向
}
void test4()
{
int n = 10;
int m = 20;
int const* const p = &n;
//*p = 20; //ok?no
//p = &m; //ok?no
//*前后都有const,既不能改变指向也不能通过指针改变指针所指变量
}
int main()
{
test1();
test2();
test3();
test4();
return 0;
}结论：const修饰指针变量的时候
1.const如果放在*的左边，修饰的是指针指向的内容，保证指针指向的内容不能通过指针来改变。 但是指针变量本⾝的内容可变.
2. const如果放在*的右边，修饰的是指针变量本⾝，保证了指针变量的内容不能修改，但是指针指向的内容，可以通过指针改变.
指针运算
指针的基本运算有三种，分别是： 1.指针+- 整数 2.指针-指针 3.指针的关系运算
指针+- 整数
这个可以用来便利内存中连续存放的类型,例如数组.代码见下:
int main()
{
int arr[10] = { 1,2,3,4,5,6,7,8,9,0 };
int* pa = &arr[0];
for (int i = 0; i < 10; i++)
{
printf("%d ", *(pa + i));
}
printf("\n");
return 0;
}指针-指针
可以用来计算字符串的长度.下面是使用和注意事项:
int main()
{
int arr[10] = { 0,1,2,3,4,5,6,7,8,9 };
char arr1[5] = { 'a','s','d','f','g' };
int* p1 = &arr[0];
int* p2 = &arr[5];
char* p3 = &arr1[0];
printf("%d\n", p2 - p1);//指针-指针,返回的是两个指针之间的元素个数
//printf("%d\n", p2 - p3);//err
//因为两个指针类型不同,不知到返回哪一个并且两个数组不是连续空间,无法判断两个数组中间相隔多少
return 0;
}指针的关系运算
可以提供另一种便利数组的方法:
int main()
{
int arr[10] = { 1,2,3,4,5,6,7,8,9,0 };
int* pa = &arr[0];
while (pa < (arr + 10))//指针的关系运算
{
printf("%d ", *pa);
pa++;
}
printf("\n");
return 0;
}野指针
概念： 野指针就是指针指向的位置是不可知的（随机的、不正确的、没有明确限制的）
野指针成因
1. 指针未初始化
2. 指针越界访问(一般出现在数组的越界)
3. 指针指向的空间释放(返回函数中局部变量的地址)
int* func()
{
int a = 0;
return &a;
}
int main()
{
//err返回已经销毁了的局部变量的地址
//int* p = func();
//可能有时候看不出错误,但是如果再调用函数破坏原来的函数栈帧,就会出现问题了
return 0;
}如何规避野指针
1.指针初始化
如果明确知道指针指向哪⾥就直接赋值地址，如果不知道指针应该指向哪⾥，可以给指针赋值NULL. NULL 是C语⾔中定义的⼀个标识符常量，值是0，0也是地址，这个地址是⽆法使⽤的，读写该地址会报错.
2.小心指针越界
3.指针变量不再使⽤时，及时置NULL，指针使⽤之前检查有效性
检查代码大概为
if ( p != NULL )
{
//代码
}
4.避免返回局部变量的地址
以上就是今天的复习啦,还有一个有用的断言,我将新开一个小篇幅的博客简单说一下~