今天我们进入指针的复习了.这部分有很多知识,话不多说,让我们进入指针的世界吧.

内存和地址

        要想学指针就不能不学内存和地址.

  内存

        其中，每个内存单元，相当于⼀个学⽣宿舍，⼀ 个字节空间⾥⾯能放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;		//errreturn 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.避免返回局部变量的地址

        以上就是今天的复习啦,还有一个有用的断言,我将新开一个小篇幅的博客简单说一下~

C语言复习--assert断言-CSDN博客