二级指针 (多级指针)

指针变量作为一个变量也有自己的存储地址，而指向指针变量的存储地址就被称为指针的指针，即二级指针。依次叠加，就形成了多级指针。指针可以指向一份普通类型的数据，例如 int、double、char 等，也可以指向一份指针类型的数据，例如 int *、double *、char * 等。如果一个指针指向的是另外一个指针，我们就称它为二级指针，或者指向指针的指针。,我们先看看二级指针，它们关系如下：

int a =100;//一个普通变量

int *p1 = &a;//一个一级指针p1指向a变量的地址

int **p2 = &p1;//一个二级指针p2指向p1指针的地址

// p2 -> p1 -> a

// &p1 &a 100

/*规律：

一级指针 指向变量的地址

二级指针 指向一级指针的地址

三级指针 指向二级指针的地址

依次类推....

指针变量也是一种变量，也会占用存储空间，也可以使用&获取它的地址。C语言不限制指针的级数，每增加一级指针，在定义指针变量时就得增加一个星号*。p1 是一级指针，指向普通类型的数据，定义时有一个*；p2 是二级指针，指向一级指针 p1，定义时有两个*。

多级指针的话就是：

int ***p3 = &p2;//三级指针

int ****p4 = &p3;//四级指针

int *****p5 = &p4;//五级指针

//实际开发中会经常使用一级指针和二级指针，几乎用不到高级指针。

想要获取指针指向的数据时，一级指针加一个*，二级指针加两个*，三级指针加三个*关系如下：

#include <stdio.h>

int main() {

int a = 100;

int *p1 = &a;

int **p2 = &p1;

int ***p3 = &p2;

printf("%d, %d, %d, %d\n", a, *p1, **p2, ***p3);//他们的值都是一样的

printf("&p2 = %#X, p3 = %#X\n", &p2, p3);//所指向的地址也是一样的

printf("&p1 = %#X, p2 = %#X, *p3 = %#X\n", &p1, p2, *p3);

printf(" &a = %#X, p1 = %#X, *p2 = %#X, **p3 = %#X\n", &a, p1, *p2, **p3);

return 0;

}

//以三级指针 p3 为例来分析上面的代码。***p3等价于*(*(*p3))。*p3 得到的是 p2 的值，

也即 p1 的地址；*(*p3) 得到的是 p1 的值，也即 a 的地址；经过三次“取值”操作后，*(*(*p3))

得到的才是 a 的值。

指针数组、指向函数的指针、指向二维数组的指针指针数组：

指针变量和普通变量一样，也能组成数组,如果一个数组中的所有元素保存的都是指针，那么我们就称它为指针数组。指针数组的定义形式一般为：

数据类型 * 名字 [数组长度]；

这里注意 [ ]的优先级比 * 来得高

int *a [10];

这里说明a是一个数组，包含了10个元素，每个元素的类型为int *。

除了每个元素的数据类型不同，指针数组和普通数组在其他方面都是一样的，下面是一个简单的例子：

#include<stdio.h>

int main(void) {

int a = 1;

int b = 2;

int c = 3;

//定义一个指针的数组

int *an[3] = { &a,&b,&c };//由于里边每一个元素都是指针，所以利用取地址符&，指向abc三个变量

//这里定义一个指向指针数组的指针，由于数组已经是指针了，所以要用到二级指针

int **p = an;//由于数组本身就是表示一个地址所以不用取地址符&

printf("%d %d %d\n", *an[0], *an[1], *an[2]);

printf("%d %d %d\n", **(p + 0) , **(p + 1), **(p + 2));

return 0;

}

//arr 是一个指针数组，它包含了 3 个元素，每个元素都是一个指针，在定义 arr 的同时，

我们使用变量 a、b、c 的地址对它进行了初始化，这和普通数组是多么地类似。

parr 是指向数组 arr 的指针，确切地说是指向 arr 第 0 个元素的指针，

它的定义形式应该理解为int *(*parr)，括号中的*表示 parr 是一个指针，

括号外面的int *表示 parr 指向的数据的类型。arr 第 0 个元素的类型为 int *，

所以在定义 parr 时要加两个 *。

指针数组还可以和字符串数组结合使用:

#include <stdio.h>

int main(){

char *str[3] = { //定义一个字符串数组 长度为3

"c.biancheng.net",

"C语言中文网",

"C Language"

};

printf("%s\n%s\n%s\n", str[0], str[1], str[2]);//依次输出每个字符串

return 0;

}

指向函数的指针:

一个函数总是占用一段连续的内存区域，函数名在表达式中有时也会被转换为该函数所在内存区域的首地址，这和数组名非常类似。我们可以把函数的这个首地址（或称入口地址）赋予一个指针变量，使指针变量指向函数所在的内存区域，然后通过指针变量就可以找到并调用该函数。这种指针就是函数指针。

数据类型 *指针名 （数据类型 参数）；

数据为函数返回值类型，指针名称，括号里边为函数参数列表。参数列表中可以同时给出参数的类型和名称，

也可以只给出参数的类型，省略参数的名称，这一点和函数原型非常类似。

注意( )的优先级高于*，第一个括号不能省略，如果写作returnType *pointerName(param list);就成了函数原型，它表明函数的返回值类型为returnType *

用指针来实现对函数的调用：

#include <stdio.h>

//返回两个数中较大的一个

int max(int a, int b){

return a>b ? a : b;

}

int main(void){

int x, y, maxval;

//定义指向函数指针*pmax

int (*pmax)(int, int) = max; //也可以写作int (*pmax)(int a, int b)

//要注意的是定义必须和函数形式一致

printf("Input two numbers:");

scanf("%d %d", &x, &y);

maxval = (*pmax)(x, y);//将函数调用并指针赋值

printf("Max value: %d\n", maxval);

return 0;

}

// maxval 对函数进行了调用。pmax 是一个函数指针，在前面加 * 就表示对它指向的函数进行调用。

注意( )的优先级高于*，第一个括号不能省略。

指向二维数组的指针：

（复盘一下二维数组的知识）二维数组在概念上是二维的，有行和列，但在内存中所有的数组元素都是连续排列的，它们之间没有“缝隙”。以下面的二维数组 a 为例：

int a[3][4] = { {0, 1, 2, 3}, {4, 5, 6, 7}, {8, 9, 10, 11} };

a就是像一个矩阵：

0 1 2 3

4 5 6 7

8 9 10 11

但在内存中，a 的分布是一维线性的，整个数组占用一块连续的内存：

【0】【1】【2】【3】【4】【5】【6】【7】【8】【9】【10】【11】

C语言中的二维数组是按行排列的，也就是先存放 a[0] 行，再存放 a[1] 行，最后存放 a[2] 行；每行中的 4 个元素也是依次存放。数组 a 为 int 类型，每个元素占用 4 个字节，整个数组共占用 4×(3×4) = 48 个字节。

C语言把一个二维数组分解成多个一维数组来处理。对于数组 a，它可以分解成三个一维数组，即 a[0]、a[1]、a[2]。每一个一维数组又包含了 4 个元素，例如 a[0] 包含`a[0][0] 、a[0][1]、a[0][2]、a[0][3]。

为了更好的理解指针和二维数组的关系，我们先来定义一个指向 a 的指针变量 p：

int (*p)[4] = a;

//括号中的*表明 p 是一个指针，它指向一个数组，数组的类型为int [4]，

这正是 a 所包含的每个一维数组的类型。

[ ]的优先级高于*，( )是必须要加的，如果赤裸裸地写作int *p[4]，那么应该理解为int *(p[4])，p 就成了一个指针数组，而不是二维数组指针。

对指针进行加法（减法）运算时，它前进（后退）的步长与它指向的数据类型有关，p 指向的数据类型是int [4]，那么p+1就前进 4×4 = 16 个字节，p-1就后退 16 个字节，那么这正好是数组 a 所包含的每个一维数组的长度。也就是说，p+1会使得指针指向二维数组的下一行，p-1会使得指针指向数组的上一行。

按照上面的定义，我们来看看代码：

#include <stdio.h>

int main(void){

int a[3][4] = { {0, 1, 2, 3}, {4, 5, 6, 7}, {8, 9, 10, 11} };

int (*p)[4] = a;

printf ( "%d\n", sizeof(*(p+1)) );//这里输出是16

return 0;

}

*(p+1)+1表示第 1 行第 1 个元素的地址：*(p+1)单独使用时表示的是第 1 行数据，放在表达式中会被转换为第 1 行数据的首地址，也就是第 1 行第 0 个元素的地址，因为使用整行数据没有实际的含义，编译器遇到这种情况都会转换为指向该行第 0 个元素的指针；就像一维数组的名字，在定义时或者和 sizeof、& 一起使用时才表示整个数组，出现在表达式中就会被转换为指向数组第 0 个元素的指针。

*(*(p+1)+1)表示第 1 行第 1 个元素的值。很明显，增加一个 * 表示取地址上的数据：**

规律：

a+i == p+i

a[i] == p[i] == *(a+i) == *(p+i)

a[i][j] == p[i][j] == *(a[i]+j) == *(p[i]+j) == *(*(a+i)+j) == *(*(p+i)+j)

#include<stdio.h>

int main(void) {

int a[3][4] = { {1,2,3,4},{5,6,7,8},{9,10,11,12} };

int i, j;

int(*p)[4] = a;//定义一个指向二维数组的指针p

for (i = 0; i < 3; i++) {

for (j = 0; j < 4; j++) {

printf("%d ", *(*(p+i)+j));//利用二级指针就可以访问到i行j列的元素

} //*(p+i)：一维数组

printf("\n"); //*(*(p+i)+j) 二维数组

}

return 0;

}

/*输出：

1 2 3 4

5 6 7 8

9 10 11 12

数组名 a 在表达式中也会被转换为和 p 等价的指针！

指针数组和二维数组指针在定义时非常相似，但是括号的位置不同所表示的意思也就天壤之别：

int *(p1[5]); //指针数组，可以去掉括号直接写作 int *p1[5];

int (*p2)[5]; //二维数组指针，不能去掉括号

指针数组和二维数组指针有着本质上的区别：

指针数组是一个数组，只是每个元素保存的都是指针，以上面的 p1 为例，在32位环境下它占用 4×5 = 20 个字节的内存。二维数组指针是一个指针，它指向一个二维数组，以上面的 p2 为例，它占用 4 个字节的内存。

至于多维数组和二维数组没有本质的区别，但是复杂度倒是高了许多。一般不常用。

结束语：

程序在运行过程中需要的是数据和指令的地址，变量名、函数名、字符串名和数组名在本质上是一样的，它们都是地址的助记符：在编写代码的过程中，我们认为变量名表示的是数据本身，而函数名、字符串名和数组名表示的是代码块或数据块的首地址；程序被编译和链接后，这些名字都会消失，取而代之的是它们对应的地址。指针就是存放地址的一种变量。

常见的的指针：

1、 指针变量可以进行四则运算。指针变量的加减运算并不是简单的加上或减去一个整数，而是跟指针指向的数据类型与地址有关。

2、给指针变量赋值时，要将一份数据的地址赋给它，不能直接赋给一个整数，例如int *p = 1000;是没有意义的，使用过程中一般会导致程序崩溃。

3、使用指针变量之前一定要初始化，否则就不能确定指针指向哪里，如果它指向的内存没有使用权限，程序就崩溃了。对于暂时没有指向的指针，直接赋值NULL让它变为空指针。

4、数组也是有类型的，数组名的本意是表示一组类型相同的数据。在定义数组时，或者和 sizeof、& 运算符一起使用时数组名才表示整个数组，表达式中的数组名会被转换为一个指向数组的指针。

指针的用法暂时就这些，C指针大法这些才是入门！继续加油咯~

作者：Mr_Li_

对啦对啦！另外的话为了帮助大家，轻松，高效学习C语言/C++，我给大家分享我收集的资源，从最零基础开始的教程到C语言项目案例，帮助大家在学习C语言的道路上披荆斩棘！可以来我粉丝群领取哦~

编程学习书籍分享：

编程学习视频分享：

整理分享（多年学习的源码、项目实战视频、项目笔记，基础入门教程）最重要的是你可以在群里面交流提问编程问题哦！

对于C/C++感兴趣可以关注小编在后台私信我：【编程交流】一起来学习哦！可以领取一些C/C++的项目学习视频资料哦！已经设置好了关键词自动回复，自动领取就好了！