指针的奥秘（一）：指针概念+指针类型+指针运算+野指针

指针

一.内存和地址1.内存2.编址 二.指针变量和指针1.取地址操作符（&）2.指针变量和解引用操作符（*）1.指针变量2.拆解指针类型3.解引用操作符4.指针变量的大小 三.指针变量的类型和意义1.指针的解引用2.指针 +- 整数3.void* 指针 四.const修饰指针1.const修饰变量2.const修饰指针变量 五.指针运算1.指针 +- 整数2.指针 - 指针3.指针的关系运算 六.野指针1.野指针成因1.指针未初始化2.指针越界访问3.指针指向的空间释放 2.如何规避野指针1.指针初始化2.小心指针越界3.避免返回局部变量的地址4.指针变量不再使用时置为NULL，指针使用之前检查有效性 七.assert断言
前言：

一谈到指针，大家的印象都是非常的难，但是指针对于C语言的学习是至关重要的，有了指针的基础，对于以后学习数据结构有很大的帮助，这是一个承上启下的过程，但是如果指针没有学好的话，学习数据结构是相当吃力地，即便是最简单的顺序表，链表。对于指针的学习，首先是不能畏惧指针，你若害怕一件事，那么迎接你的大概是你最不希望看到的，生活也是如此。所以要有一种迎难而上的精神，要对自己充满信心，抱着一定能学好指针的态度，即便过程艰辛但结局完美，也不辜此行。那么从现在开始，行动起来吧，自信的你才是最完美的自己！

一.内存和地址

1.内存

 在理解指针之前我们需要知道计算机中的内存分配。

计算机上CPU（中央处理器）在处理数据的时候，需要的数据是在内存中读取的，处理后的数据也会放回内存中，那我们买电脑的时候，电脑上内存有8GB/16GB/32GB等，那这些内存空间如何高效的管理呢？其实计算机把内存划分为⼀个个的内存单元，每个内存单元的大小为1个字节。

  将内存比作学校，内存单元就好比⼀个个教室，⼀个字节空间里面能放8个比特位，就好比教室里只能存在8个人，每个人是⼀个比特位。每个内存单元也都有⼀个编号（这个编号就相当于教室的门牌号），有了这个内存单元的编号，CPU就可以快速找到这个内存空间（教室）。生活中我们把门牌号也叫地址，在计算机中我们把内存单元的编号也称为地址。C语⾔中给地址起了新的名字叫：指针。

所以我们可以理解为：内存单元的编号 == 地址 ==指针

2.编址

CPU访问内存中的某个字节空间，必须知道这个字节空间在内存的什么位置，而因为内存中字节很多，所以需要给内存进行编址(就如同教室很多，需要给教室编号⼀样)。计算机中的编址，并不是把每个字节的地址记录下来，而是通过硬件设计完成的。首先，必须理解，计算机内是有很多的硬件单元，而硬件单元是要互相协同工作的。所谓的协同，至少相互之间要能够进行数据传递。但是硬件与硬件之间是互相独立的，那么如何通信呢？答案很简单，用"线"连起来。而CPU和内存之间也是有⼤量的数据交互的，所以，两者必须也用线连起来。不过，我们今天关心⼀组线，叫做地址总线。我们可以简单理解，32位机器有32根地址总线，每根线只有两中状态，表示0,1【电脉冲有无】，⼀根线，能表示2种含义，2根线就能表示4种含义，依次类推。32根地址线，就能表示2 ^ 32种含义，每⼀种含义都代表⼀个地址。所以32位机器共有2 ^ 32个地址。地址信息被下达给内存，在内存上，就可以找到该地址对应的数据，将数据在通过数据总线传入CPU内寄存器。

二.指针变量和指针

1.取地址操作符（&）

在C语⾔中创建变量其实就是向内存中的栈区申请空间，比如，上述的代码就是创建了整型变量a，向内存中申请4个字节，用于存放整数10，其中每个字节都有地址，上图中4个字节的地址分别是：0x00CFF9C,0x00CFF9D,0x00CFF9E,0x00CFF9F。按照我画图的例子，会打印处理：0x00CFF9C。&a取出的是a所占4个字节中地址较小的字节的地址。虽然整型变量占用4个字节，我们只要知道了第⼀个字节地址，顺藤摸瓜访问到4个字节的数据也是可行的。

2.指针变量和解引用操作符（*）

1.指针变量

#include <stdio.h>int main(){int a = 10;int* pa = &a;//取出a的地址并存储到指针变量pa中 return 0;}

那我们通过取地址操作符(&)拿到的地址是⼀个数值，比如：0x0012FF40，这个数值有时候也是需要存储起来，方便后期再使用的，那我们把这样的地址值存放在哪⾥呢？答案是：指针变量中。如图：

指针变量也是⼀种变量，这种变量就是用来存放地址的，存放在指针变量中的值都会理解为地址。我们口头说的指针是指针变量。

2.拆解指针类型

#include <stdio.h>int main(){int a = 10;int * pa = &a;return 0;}

我们看到pa的类型是 int* ，我们该如何理解指针的类型呢？如图：

3.解引用操作符

#include <stdio.h>int main(){int a = 100;int* pa = &a;*pa = 0;printf("%d\n", a);//输出0return 0;}

*pa表示什么意思呢？如图：

通过指针来修改，指针所指向的内容，就多了一种途径，体现出代码的灵活，那到底为什么要这样做呢？跟着我将指针学完，你就懂了。

4.指针变量的大小

#include <stdio.h>//指针变量的大小取决于地址的大小//32位平台下地址是32个bit位（即4个字节） //64位平台下地址是64个bit位（即8个字节） 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位平台下（x86）地址是32个bit位，指针变量大小是4个字节。64位平台下（x64）地址是64个bit位，指针变量大小是8个字节。注意：指针变量的大小和类型是无关的，指针类型的变量，在相同的平台下，大小都是相同的。

三.指针变量的类型和意义

1.指针的解引用

以下给出两类代码，理解指针变量类型的意义

代码1：

#include <stdio.h>int main(){int n = 0x11223344; int *pi = &n;  *pi = 0; return 0;}

调试我们可以看到，代码1会将n的4个字节全部改为0。

代码1：

#include <stdio.h>int main(){int n = 0x11223344;char* pc = (char*)&n;*pc = 0;return 0;}

调试我们可以看到，代码2只是将n的第⼀个字节改为0。

结论：

指针的类型决定了，对指针解引用的时候有多大的权限（⼀次能操作（访问）几个字节）。比如： char* 的指针解引用就只能访问⼀个字节，而 int* 的指针的解用就能访问四个字节。这就是代码1与代码2不同的根本原因。

2.指针 ± 整数

先来一段代码，观察地址的变化

int main(){int n = 10;char* pc = (char*)&n;int* pi = &n;printf("&n=   %p\n", &n);printf("pc=   %p\n", pc);printf("pc+1 =%p\n", pc + 1);printf("pi=   %p\n", pi);printf("pi+1= %p\n", pi + 1);return 0;}

我们可以看出， char* 类型的指针变量+1跳过1个字节， int* 类型的指针变量+1跳过了4个字节。这就是指针变量的类型差异带来的变化。指针+1，其实跳过指针指向的元素的类型的大小（字节数）。指针可以+1，那也可以-1。

结论：

指针的类型决定了指针向前或者向后走一步有多大（距离）。

3.void* 指针

在指针类型中有⼀种特殊的类型是 void * 类型的，可以理解为无具体类型的指针（或者叫泛型指针），这种类型的指针可以用来接受任意类型地址。但是也有局限性， void* 类型的指针不能直接进行指针的±整数和解引用的运算。因为不知道一次访问/跳过多少个字节，但是可以先强制类型转换，再进行指针的±整数和解引用的运算。⼀般 void* 类型的指针是使用在函数参数的部分，用来接收不同类型数据的地址，这样的设计可以实现泛型编程的效果。由于这篇文章是初识指针，这一部分放在之后讲解。

四.const修饰指针

1.const修饰变量

变量是可以修改的，但是如果我们希望⼀个变量加上一些限制，不能被修改，怎么做呢？这就是const的作用。

#include <stdio.h>int main(){ int m = 0; m = 20;//m是可以修改的  const int n = 0; n = 20;//n是不能被修改的  return 0;}

上述代码中n是不能被修改的，其实n本质是变量，只不过被const修饰后，在语法上加了限制，只要我们在代码中对n进行修改，就不符合语法规则，就报错，致使没法直接修改n。

但是如果我们绕过n，使用n的地址，去修改n就能做到了，虽然这样做是在打破语法规则。

int main(){ const int n = 0;printf("n = %d\n", n); int* p = &n; *p = 20; printf("n = %d\n", n); return 0;}

我们可以看到这里⼀个确实修改了，但是我们还是要思考⼀下，为什么n要被const修饰呢？就是为了不能被修改，如果p拿到n的地址就能修改n，这样就打破了const的限制，这是不合理的，所以应该让p拿到n的地址也不能修改n，那接下来怎么做呢？于是就有了const修饰指针变量。

2.const修饰指针变量

⼀般来讲const修饰指针变量，可以放在 * 的左边，也可以放在 * 的右边，也可以放在两边，意义是不⼀样的。以下为三种可能代码：

int* p//没有const修饰int const *p//const 放在*的左边做修饰等价于const int *pint* const p//const 放在*的右边做修饰int const * const p //const 放在*的左右两边做修饰

我们看下面代码，来分析具体分析⼀下：

#include <stdio.h>//代码1 - 测试⽆const修饰的情况 void test1(){int n = 10;int m = 20;int* p = &n;*p = 20;//okp = &m; //ok}//代码2 - 测试const放在*的左边情况 void test2(){int n = 10;int m = 20;const int* p = &n;*p = 20;//errp = &m; //ok}//代码3 - 测试const放在*的右边情况 void test3(){int n = 10;int m = 20;int* const p = &n;*p = 20; //okp = &m; //err}//代码4 - 测试*的左右两边都有const void test4(){int n = 10;int m = 20;int const* const p = &n;*p = 20; //errp = &m; //err}int main(){//测试⽆const修饰的情况 test1();//测试const放在*的左边情况 test2();//测试const放在*的右边情况 test3();//测试*的左右两边都有const test4();return 0;}

const修饰指针变量的时候的结论：

无const修饰的指针：指针变量本身的内容可变，指针指向的内容，也可以通过指针改变。const如果放在 * 的左边：修饰的是指针指向的内容，保证指针指向的内容不能通过指针来改变。但是指针变量本身的内容可变。const如果放在 * 的右边：修饰的是指针变量本⾝，保证了指针变量的内容不能修改，但是指针指向的内容，可以通过指针改变。const如果放在 * 的左右两边：保证了指针变量的内容不能修改，以及保证指针指向的内容不能通过指针来改变。

五.指针运算

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++){printf("%d ", *(p + i));//p+i 这里就是指针+整数 }return 0;}

p指向整形元素arr[0]，p+1跳过4个字节，也就是1个整形，所以p+1指向整形元素arr[1]。p一次访问4个字节，也就是一个整形，得到arr[0]。同理*(p+1)得到arr[1]，按照指针的方法就可以打印数组所有的元素。其实：arr[0]本质就是*(p+0), arr[i]==*(p+i)。还有：数组名arr就是首元素的地址，也就是arr[0]的地址，也可以这么写，arr[0]等价于* (arr+0), arr[i]等价于* (arr+i)。

2.指针 - 指针

大指针 - 小指针得到的是指针之间元素的个数，仅限于它们是同一块空间 还有小指针 - 大指针得到的就是负数。例如：

#include <stdio.h>//指针 - 指针int main(){int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };int* p1 = &arr[0];int* p2 = &arr[6];printf("%d\n", p1 - p2);//-6printf("%d\n", p2 - p1);//6return 0;}

数组再内存中是连续存放的，且是由低地址向高地址存放的。

3.指针的关系运算

指针还能够比较大小，指针本质是地址，地址以16进制显现出来的，所以本质就是比较两个数的大小。

#include <stdio.h>int main(){int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };int* p = &arr[0];int sz = sizeof(arr) / sizeof(arr[0]);while (p < arr + sz) //指针的大小比较 {printf("%d ", *p);//打印数组所有的元素p++;}return 0;}

六.野指针

概念：野指针就是指针指向的位置是不可知的（随机的、不正确的、没有明确限制的），是非常危险的。

1.野指针成因

1.指针未初始化

//1.指针未初始化#include <stdio.h>int main(){int* p;//局部变量指针未初始化，没有明确的指向，默认为随机值 *p = 20;//非法访问内存了，p就是野指针//随机将p指向的对象改变是非常危险的，这是错误的做法return 0;}

2.指针越界访问

//2.指针越界访问#include <stdio.h>int main(){int arr[10] = { 0 };int* p = &arr[0];int i = 0;for (i = 0; i <= 11; i++){//当指针指向的范围超出数组arr的范围时，p就是野指针 //我们没有权限访问及修改，这片空间*(p++) = i;}return 0;}

3.指针指向的空间释放

//3.返回局部变量的地址（生命周期结束后使用）int* test(){int a = 10;return &a;}int main(){int* p = test();//p中存着a的地址，a已经还给操作系统了，p不能使用这块空间，p就是野指针//但是内存里的这块空间还在，只是不属于当前程序，没有使用着块空间的使用权限printf("%d\n", *p);//通过非法的地址，如果这块空间没有被使用（覆盖），还能找到10，但是不属于我们。return 0;}

2.如何规避野指针

1.指针初始化

如果明确知道指针指向哪里就直接赋值地址，如果不知道指针应该指向哪里，可以给指针赋值NULL。NULL 是C语言中定义的⼀个标识符常量，值是0，0也是地址，这个地址是无法使用的，读写该地址会报错。

代码如下：

#include <stdio.h>int main(){int num = 10;int* p1 = &num;int* p2 = NULL;return 0;}

2.小心指针越界

⼀个程序向内存申请了哪些空间，通过指针也就只能访问哪些空间，不能超出范围访问，超出了就是越界访问。导致野指针。

3.避免返回局部变量的地址

如造成野指针的第3个例子，不要返回局部变量的地址。

4.指针变量不再使用时置为NULL，指针使用之前检查有效性

当指针变量指向⼀块区域的时候，我们可以通过指针访问该区域，后期不再使用这个指针访问空间的时候，我们可以把该指针置为NULL。因为约定俗成的⼀个规则就是：只要是NULL指针就不去访问，同时使用指针之前可以判断指针是否为NULL。我们可以把野指针想象成野狗，野狗放任不管是非常危险的，所以我们可以找⼀棵树把野狗拴起来，就相对安全了，给指针变量及时赋值为NULL，其实就类似把野狗栓起来，就是把野指针暂时管理起来。不过野狗即使拴起来我们也要绕着走，不能去挑逗野狗，有点危险；对于指针也是，在使用之前，我们也要判断是否为NULL，看看是不是被拴起来起来的野狗，如果是不能直接使用，如果不是我们再去使用。

#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;for (i = 0; i < 10; i++){*(p++) = i;}//此时p已经越界了，可以把p置为NULL p = NULL;//下次使⽤的时候，判断p不为NULL的时候再使⽤ //...p = &arr[0];//重新让p获得地址 if (p != NULL) //判断 {//...}return 0;}

七.assert断言

assert.h 头文件定义了宏 assert() ，用于在运行时确保程序符合指定条件，如果不符合，就报错终止运行。这个宏常常被称为“断言”。

assert(p != NULL);

验证变量 p 是否等于 NULL 。如果确实不等于 NULL ，程序继续运行，否则就会终止运行，并且给出报错信息提示。

初识指针到这里就结束了，日后还会更新指针的奥秘（2.0）以及（3.0）等等。不要错过了哦。
觉得我写的不错的，可以给个三连哦，您的支持将是我对日后更新最大的动力，感谢啦！！！！