指针是c语言为什么如此流行的一个重要原因，正是有了指针的存在，才使得c/c++能够可以比使用其他语言编写出更为紧凑和有效的程序，可以说，没有掌握指针，就没有权利说自己会用c/c++.然而。然而对于大多数初学者，面对指针这个概念简直是望而生畏，如果前期指针运用的不熟练，后期编写的程序随时都有可能成为一颗定时炸弹，因此今天我就花点时间给大家解释一下我自己对c/c++中指针的理解。
我们知道，计算机内存的每个字节都有一个唯一的地址，CPU每次寻址就是通过固定的步长（这就解释了为什么需要内存对齐）来跳跃进行寻址的。举个例子，我们可以把内存看做是一条长街上的一排房屋，每个房屋都有自己固定的门牌号，每座房屋里面都可以容纳数据，为了读取到某个房屋里面的数据，我们必须知道这个房屋的门牌号，根据这个门牌号来打开这个房间，取走数据。同样，计算机也必须为每个内存字节都编上号码，就像门牌号一样，每个字节的编号是唯一的，根据编号可以准确地找到某个字节。
当我们在程序中声明一个变量并给这个变量赋值的时候，编译器做了什么呢？实际上，变量名代表内存中的一个存储单元，在编译器对程序编译连接的时候由系统给变量分配一个地址：
int a = 10;
上面这行代码我们定义并初始化了这个变量a，系统会为a分配一块内存单元，a只是这块内存单元的别名，在程序中从变量中取值，实际上是通过变量名找到相应的内存单元，从其中读取数据。
假如系统为变量 a 分配的内存地址为0xFF00, 那么我们可以说这个地址就是变量 a 的门牌号。一个变量的地址称为该变量的指针。所以说，指针的本质就是地址，指针变量是一种特殊的变量，它专门保存指针(也即地址)，当我们说这个地址对应的内存单元的时候，我们可以说这个指针指向这块内存单元。
例如：
int a = 10; int* p = &a; //定义指针变量 p *p = 20; //将指针p指向的值修改为 20
上面两行代码中，我们首先定义了一个整型变量 a ,然后又定义了一个指针变量 p 指向 a .第二行代码中，符号&代表取地址，相当于把变量a的地址赋值给了指针变量p(p指向a)，*加在指针变量前面代表解引用，意思找到指针p指向的值，因此，第三行代码的意思就是讲p指向的值也就是a修改为20.总之一定要记住，符号&代表取值，符号*代表解引用：
| 符号 |
意义 |
| & |
取地址 |
| * |
解引用 |
这三行代码的内存模型如下：
我们假设系统给变量 a 分配的内存首地址为2000，我们又声明了一个指针变量p，这个p也是要占用内存空间的（32位系统占用4个字节，64位系统占用8个字节，请思考为什么），只不过这个变量p保存的内容是变量a的地址，也就是2000，当我们想通过p来操纵a的话，首先要根据p保存的地址找到它指向的内容，也就是解引用*p，当*p的内容放生改变的时候，首地址为2000的内存单元存储的值也会做出改变，因此变量当*p被重新赋值为20的时候，变量a的值也会做出改变，变为20.
由此扩展到二级指针，如果我们再定义一个指针变量q来指向p，那么q就是一个二级指针，因为它指向的对象还是一个指针，只不过比他自己低一级，是一级指针,那么二级指针如何定义呢，请看下面的代码：
int a = 10; int* p = &a; int** q = &p;
上面第三行代码就是定义了一个二级指针q，它指向的是一级指针p，而一级指针p又指向了变量a，它的内存模型如下图所示：
二级指针q保存的内容为一级指针p的地址而非内容，注意p地址是2008，p的内容为2000. 因此对q进行解引用也即*q得出的是p,也就是2008,再对(*q)进行解引用也即*(*q)得出的才是变量a的值，由于运算符的结合性自右向左，因此括号可以省略，也即**q才是a的值。我们可以编写代码试一下：
cout <<"a的值为："<< **q << endl;
我们观察一下输出结果：
没错，输出的结果完全正确。
由此再扩充到多级指针，二级指针是指向一级指针的指针，那么n级指针便是指向n-1级指针的指针，以此类推。
请看下面两行代码：
int a = 10; const int * p1 = &a; //常量指针 int * const p2 = &a; //指针常量
上面第二行代码中的p1是一个常量指针，就是指向常量的指针变量。意味着它指向的值不可以修改，但是指针的指向可以修改：
int a = 10; int b = 20; const int * p1 = &a; //常量指针 *p1 = 100; //错误，常量指针指向的值不可以修改 p1 = &b; //正确
而对于指针常量，它本质是一个常量，但是由指针修饰。意味着它指向的值可以修改，但是指针的指向不可修改，与常量指针刚刚相反：
int a = 10; int b = 20; int * const p1 = &a; //指针常量 *p1 = 100; //正确 p1 = &b; //错误，指针的指向不可以修改
因此，我们总结下：
| 名称 |
意义 |
特点 |
| const int * p |
常量指针 |
指向可修改，指向的值不可修改 |
| int * const p |
指针常量 |
指向不可修改，指向的值可修改 |
我们知道，一维数组名本身就是一个指针，但是在使用的过程中要小心，因为这个指针分为指向数组首元素的指针与指向整个数组的指针，那么如何区分它们呢？我们来看下面几行代码：
int arr[] = {1, 2, 3, 4, 5};
int* p1 = arr;
int* p2 = &arr[0];
int* p3 = &arr; //报错
上面三行代码中，其中p1与p2是等价的，因为数组名arr本身就是一个指针，但是这个指针不是指向整个数组，而是指向数组的首元素的地址。第四行直接报错，因为&arr指的是整个数组的指针，不能把数组指针赋值给整形指针。虽然arr与&arr在数值上是相同的，但是两者意义不同。意味着&arr它的步长为整个数组，而对于arr，步长为单个元素。
所以，我们得出结论，对于一维数组arr：
| 名称 |
意义 |
步长 |
| arr |
指向数组首元素 |
单个元素 |
| &arr[0] |
指向数组首元素 | 单个元素 |
| &arr |
指向整个数组 |
整个数组 |
在定义了指向数组首元素的指针变量后，我们可以通过这个指针变量来访问数组元素：
int arr[] = { 1,2,3,4,5 };
int* p1 = arr;
int length = sizeof(arr) / sizeof(int);
for (int i = 0; i < length; i++)
{
cout << p1[i] << endl;
cout << *(p1 + i) << endl;
}
上面几行代码中，p1[i]与*(p1+i)两者是等价的，所以输出的结果一样。但是要注意，当用sizeof操作符操作arr的时候，这个时候不能把arr当做一个指针来对待，因为sizeof操作数组的时候它返回的是数组的字节长度，而单个指针变量只占用四个字节。上面循环体中，我们也可以通过下面方式访问：
cout << *p1++ << endl; cout << *(p1++) << endl;
*p1++与*(p1++)是等价的，这是因为++的运算符优先级比*要高，因此不管你加不加括号，都会优先执行p++，然而p++是先返回p的值，再与*结合，最后p再向后移动一位。
不过在这里要特别注意，有一种情况下我们是不能通过sizeof操作符来计算数组的长度的，就是当数组名作为函数参数传递的时候：
void test(int arr[])
{
int lenth = sizeof(arr) / sizeof(int);
}
上面这行代码语法上没有问题，但是得出的结果却不是我们想要的结果，为什么呢，这是因为数组名作为函数传递的时候，会退化成一个指针，如果是二维数组的话，会退化成指向一维数组的指针，所以sizeof(arr)计算出来的结果就不是数组的字节长度了。所以说，在c/c++中传递数组的时候，一般我们也会把数组的长度作为形参传递过去。
但是我们不能通过下面方式去访问数组元素：
cout << *arr++ << endl; //报错
这是因为arr本身是一个指针常量，指针的指向不可更改，因此编译器直接报错。
数组指针顾名思义，本质就是一个指针，这个指针指向整个数组；指针数组本质上是一个数组，但是数组的每个元素都是指针。请看下面两行代码：
int *p1[10]; //指针数组 int (*p2)[10]; //数组指针
上面两行代码，p1是一个数组，而p2却是一个指针，它指向一个匿名数组。为什么是这样呢？这是因为[]的优先级比*要高。p1 先与[]结合，构成一个数组的定义，数组名为p1，int *修饰的是数组的内容，即数组的每个元素。那现在我们清楚，这是一个数组，其包含10 个指向int 类型数据的指针，即指针数组。至于p2 就更好理解了，在这里括号的优先级比[]高，*号和p2 构成一个指针的定义，指针变量名为p2，int 修饰的是数组的内容，即数组的每个元素。数组在这里并没有名字，是个匿名数组。那现在我们清楚p2 是一个指针，它指向一个包含10 个int 类型数据的数组，即数组指针。
p1为数组名，每个元素都是int型指针
p2为指针变量，指向一个匿名数组
如果我们定义：
int(*p)[10] = &arr;
那么如何访问数组的元素呢？且看，由于上行代码中，p=&arr，那么对其解引用，*p就是arr，因此我们可以通过(*p)[]来进行访问数组的元素：
for(int i = 0; i < 10; i++)
{
cout<< (*p)[i] << endl;
}
指针函数顾名思义，他是一个函数，但返回值是一个指针，例如下面这几行代码：
int* test()
{
int a = 10;
int* p = &a;
return p;
}
这个test就是一个指针函数，它返回的是一个int型的指针。
函数指针本质是一个指针，这个指针指向一个函数，那么我们如何定义函数指针呢？请看下面代码：
int myAdd(int a, int b)
{
return a + b;
}
void test()
{
int(*pFun)(int, int) = myAdd; //定义一个函数指针
cout << (*pFun)(2, 5) << endl; //用函数指针调用函数
cout << pFun(2, 5) << endl; //用函数指针调用函数
}
上面test函数代码中，我们定义了一个函数指针，在最后进行调用函数的时候，有两种方法，一种是用*pFun来调用，一种是直接用pFun来调用，可见两种方法结果都一样。
最后，我们来看个比较混合指针复杂的案例：
char *(* c[10])(int **p);
乍一看，让人眼花缭乱，不知道是什么东西，在这里请大家记住一个规则：C语言标准规定，对于一个符号的定义，编译器总是从它的名字开始读取，然后按照优先级顺序依次解析。注意是从名字开始，不是从开头也不是从末尾，这是理解复杂指针的关键。
有了上面的规则，我们来逐步剖析上面哪行代码的意义：
首先从*c[10]开始，由于[]的优先级比*高，因此，*c[10]代表一个指针数组，每个元素都是指针，但类型还不知道。再看右边的(int** p)，它是一个函数，参数为一个二级指针。最左边char* 代表这个函数的返回类型。因此，整行代码的含义就是：c 是一个拥有 10 个元素的指针数组，数组每个元素指向一个原型为char *(int **p)的函数。
