C生万物 | 火眼辨析指针数组与数组指针
本文我们来讲讲C语言中的易混淆的指针数组与数组指针✒
文章目录
- 一、指针数组
-
- 1、概念明细
- 2、数组地址偏移量与指针偏移量
- 3、指针变量与数组名的置换【✔】
- 4、实例讲解
-
- ① 指针数组存放地址
- ② 指针数组存放数组
- 二、数组指针
-
- 1、数组指针的定义
- 2、&数组名VS数组名
- 3、数组指针的使用【⭐】
- 三、数组传参与指针传参
-
- 1、 一维数组传参
- 2、 二维数组传参
- 3、 一级指针传参
- 4、 二级指针传参
- 四、总结与提炼
一、指针数组
首先我想问你一个问题：指针数组是一个指针还是一个数组呢？
1、概念明细
- 好，解答一下上面的问题，对于【指针数组】来说，它是一个
数组，而不是指针
int arr1[5]; //整型数组 - 存放整数的数组
char arr2[5]; //字符数组 - 存放字符的数组
int* arr3[5]; //指针数组 - 存放指针的数组
- 来看一下上面这三个数组的定义
- 对于
arr1，他是一个整型数组，它里面存放的都是整数； - 对于
arr2，他是一个字符数组，它里面存放的都是字符； - 对于
arr3，他是一个指针数组，它里面存放的都是指针；
- 对于
- 通过这么的对比相信你对【指针数组】有了一初步的概念，它也是一个数组，里面放的都是指针
下面两个模块我将带你来回顾一下数组中的相关知识
2、数组地址偏移量与指针偏移量
- 首先对于一个数组而言，我们如果可以得到它的首元素地址，然后通过这个地址就可以顺藤摸瓜就可以获取到后面的所有元素
- 但是光这么直接用
arr[0]来访问太累了，不妨我们将数组的首元素地址给到一个指针变量，让它保存下这个地址，然后让它逐步地向后移动。如果对指针还不是很了解的看看这篇文章——> 底层之美，莫过于C【1024，从0开始】先去了解一下什么是指针
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
int* p = &arr[0];
- 可以看到，指针变量里面存放着的是数组arr的首元素地址，那我们现在要通过这个指针变量去访问到后面的所有元素该怎么做呢？
- 首先我们考虑先访问到第二个元素，要访问到一个元素首先考虑找到这个元素所在的地址，
p指针第一个元素所在的地址，那么p + 1便是指向2所在元素的地址，那要访问到这个地址上所在的内容，那就要使用到*这个符号，对这块地址进行解引用*(p + 1)，此时就可以访问到2这个元素了。那找3，找4也是一样的，只需要让这个指针向后偏移即可，所以我们可以通过循环去找，访问第i个元素便是*(p + i) - 可能有些同学还是不太理解，没关系，我们通过代码来验证一下
for (int i = 0; i < 10; ++i)
{
printf("%p == %p\n", p + i, &arr[i]);
}
printf("\n");
- 可以看到，无论是对于
p + i还是&arr[i]，它们每次所访问的地址都是一样的，这其实也就意味着指针变量p在偏移的过程中相当于在代替数组首元素地址向后偏移
有了这些知识作为铺垫，我们就可以去尝试访问数组中的所有内容了
因为一维数组是一块连续的存储空间，所以我们只要得到这个数组的首元素地址。就可以通过p + i这样的方式找到它之后所有元素的地址，并且把他们地址进行解引用便能访问到数组中的所有元素
int main(void)
{
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
int* p = &arr[0];
for (int i = 0; i < 10; ++i)
{
printf("%d ", *(p + i));
}
printf("\n");
return 0;
}
- 可以看到，通过将数组的首元素地址给到指针变量p，然后再使这个指针变量一位一位地向后偏移，每次偏移一个元素即4个字节，第i个元素的地址即为
p + i，而当我们要去访问这个地址的内容时，直接对其进行解引用即可*(p + i)，然后便可以看到数组中的十个元素都被打印出来了
3、指针变量与数组名的置换【✔】
- 因为【数组名 = 首元素地址】，那不妨
int* p = &arr[0]便可以写成int* p = arr，Ctrl + F5让代码走起来可以看到结果也是一样的
- 那我这么做就相当于是把arr赋给了p，那此时
arr和p也就是一回事，那也可以说【arr <==> p】，所以我们在使用到arr的地方可以换成p，使用到p的地方可以换成arr
- 那这个时候突然就想到一点我们上面在打印数组元素的时候都是使用
arr[i]，那此时是不是可以将arr[i]和*(arr + i)做一个联系呢？当然是可以的
- 因为arr为数组名，数组名表示这个数组的首元素地址。首元素地址向后偏移i个位置之后到达下标为i的那个元素所在的位置，再对其进行解引用就找到下标为i这个地址所对应的元素——这也就是对于【*(arr + i)】的一个解释
- 那对于【arr[i]】又要怎么去解释呢？还记得我一开始讲一维数组的使用时说到
[]是一个数组访问的操作符，那既然是操作符的话就会有操作数，操作数是谁呢？就是【arr】和【i】，那此时当我将arr[i]转换成*(arr + i)的时候，()里面的也就是这两个操作数，根据加法的交换律就可以将【arr】和【i】进行一个交换，那也就变成了*(i + arr)。 - 此时就可以去进行一个类推，因为
*(arr +i)可以写成arr[i]<—— ⭐ - 那么
*(i + arr)是否可以写成i[arr]呢 <——⭐
此时我们通过代码来尝试一下，将推测转化为实际
- 可以看到，依旧是可以的w(ﾟДﾟ)不过这种写法了解一下即可，不是很好理解，也不会用到
- 刚才有说到
arr和p其实是一回事，那可以写【arr[i]】，是不是也可以写成【p[i]】呢？答案是：当然可以！
看完上面的这些，相信你已经晕了(((φ(◎ロ◎;)φ)))，不过没有关系，将知识点做个总结就可以很清晰了
arr[i] == *(arr + i) == *(p + i) == p[i]
4、实例讲解
回顾了数组的相关知识后，再来看【指针数组】相关内容，就变得易如反掌✋
① 指针数组存放地址
- 好，首先来看到第一个案例，我定义了五个变量分别对它们进行了一个初始化，然后定义了一个指针数组，首先你要想到的就是
[指针接受地址]这个概念 - 所以我将这五个变量的地址都存放到了这个【指针数组】中，然后去遍历这个数组便可以访问到这五个变量的地址了
int main(void)
{
int a = 1;
int b = 2;
int c = 3;
int d = 4;
int e = 5;
int* arr[5] = { &a, &b, &c, &d, &e };
for (int i = 0; i < 5; ++i)
{
printf("%d ", *(arr[i]));
}
printf("\n");
return 0;
}
- 接下去你要想到的就是
[解引用]这个知识点，我说到指针其实就是地址，那对地址进行一个解引用其实可以将[*]和[&]进行一个抵消，这也就取到了五个变量的地址，通过下标i控制就遍历到了这五个变量
② 指针数组存放数组
- 好，再来看下面这段代码，我定义了三个整型数组，数组的个数都是5，然后又定义了一个指针数组，将三个整型数组的数组名都存放进去，我们知道
数组名即为首元素地址，所以这是合法的 - 接下去我就要通过这个指针数组访问到这三个整型数组中的所有元素
int arr1[5] = { 1, 1, 1, 1, 1 };
int arr2[5] = { 2, 2, 2, 2, 2 };
int arr3[5] = { 3, 3, 3, 3, 3 };
int* parr[3] = { arr1, arr2, arr3 };
for (int i = 0; i < 3; ++i)
{
for (int j = 0; j < 5; ++j)
{
printf("%d ", *(parr[i] + j));
}
printf("\n");
}
- 通过算法图示来看看，外层的遍历，可以访问到这个三个数组的首元素地址，此时我们若还要去访问到每个数组中的元素的话，就要再通过一个内部的循环去遍历每一个数组，这个操作的话相信你看过我的数组文章一定是没问题的
- 这里的
parr[i] + j也就是位于每个数组的首地址向后偏移j个位置，所以访问到的就是下标为j这个位置的地址，但是我们要访问值的话就要加上一个解引用的操作。当然，通过【*】和【()】的规则我们也可以将*(parr[i] + j)转换为*(*(parr + i) + j)或者是parr[i][j]
- 来看一下运行结果
在学习了【指针数组】后，来辨析一下三个数组吧
int* arr1[10];
char* arr2[4];
char** arr3[5];
- 首先第一个arr1，数组大小为10，数组里面存放的都是
int*的整型指针 - 然后第二个arr2，数组大小为4，数组里面存放的都是
char*的字符指针 - 最后第三个arr3，数组大小为5，数组里面存放的都是
cahr**的二级字符指针
二、数组指针
讲完指针数组后，我们就来讲讲它的双胞胎兄弟 —— 【数组指针】
首先还是这个问题，数组指针是指针？还是数组？
1、数组指针的定义
- 我们通过指针初阶中所学习的整型指针和字符指针来做一个对比
int a = 10;
char ch = 'x';
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
int* pa = &a; —— 整型指针 - 存放整型地址的指针
char* pc = &ch; —— 字符指针 - 存放字符地址的指针
int(*parr)[10] = &arr; —— 数组指针 - 存放数组地址的指针
- 也是一样来分析一下这三个指针
- 对于
pa，它是一个整型指针，里面存放的是一个整型的地址 - 对于
pc，它是一个字符型指针，里面存放的是一个字符的地址 - 对于
parr，它是一个数组指针，里面存放的是一个数组的地址
- 对于
- 通过这么的对比相信你对【数组指针】有了一初步的概念，它也是一个指针，它所指向的是一个数组的地址
然后就来仔细介绍一下数组指针
- 下面有一个arr数组，数组里面有5个元素，每个元素都是一个
int类型。那现在我要将这个数组的地址存起来，那肯定需要一个指针来接收，那既然是一个指针的话我们肯定会想要用*做修饰，不过这还不够，因为接收的是一个数组的地址，所以我们还会想要再加上[10]，而且这个10还不能像我们定义数组的可以省略调用，一定要加上 - 但是像下面这样真的可以吗？或许你应该去了解一下运算符优先级，因为
[]的优先级是最高的，所以这个【pa】会首先和[]结合，而不是先和*，那么它就是一个数组，而不是指针了！
int arr[5] = { 1,2,3,4,5 };
int* pa[10] = &arr;
- 若是想要【pa】和这个
*先结合的话，在它们的外面加上一个()即可，如下所示
int (*pa)[10] = &arr;
这才是一个完整又正确的【数组指针】
2、&数组名VS数组名
对于数组名是首元素地址这个说法我们已经是耳熟于心了，不过上面看到了一个新的写法
&数组名，这和数组名存在着什么关联呢？本模块我们就来探讨一下这个
- 可以看到，在下面我分别打印了三种情形，那可以预测第一种和第二种是一样的，而第三种可能就不一样
int arr[5] = { 1,2,3,4,5 };
printf("%p\n", arr);
printf("%p\n", &arr[0]);
printf("%p\n", &arr);
但是从运行结果可以看到它们都是一样的，这是为什么呢？
- 在数组章节我就有讲到过
&数组名值得是取出整个数组的地址，而&arr[0]则是数组首元素的地址。不过从下图可以看，它们的位置是一样的，所以打印出来的地址就是一样的
那有同学说：难道它们就完全相同吗，那&数组名还有什么意义呢？
- 但此时我将当前取到的地址再去 + 1的话，会有什么变化呢？
printf("%p\n", arr);
printf("%p\n", arr + 1);
puts("---------------");
printf("%p\n", &arr[0]);
printf("%p\n", &arr[0] + 1);
puts("---------------");
printf("%p\n", &arr);
printf("%p\n", &arr + 1);
puts("---------------");
可以看到，最后一个&数组名和上面两个的结果不同
- 对于
arr和&arr[0]都一样，取到的是首元素的地址，这是一个整型数组，首元素是一个int类型的数据，那么其地址就是int*类型，那在【指针初阶部分】我有讲到过一个int*的指针一次可以访问4个字节的大小，那在这数组中每个元素都占4个字节，所以 + 1就会跳过一个元素也就是4个字节 - 对于
&arr来说，取出的是整个数组的大小，虽然它的位置和首元素地址是一样的，但是它 + 1跳过的确是整个数组的大小，上面说到过一个数组的地址给到【数组指针】来接收int (*parr)[5] = &arr;，此时去掉它的变量名后这个指针的类型就是int(*)[10]，上面我们也有讲过一个指针一次可以访问的字节取决于它的类型
具体可以看看这张图
在知晓了这一点后许多同学就明白了这个地址的偏移为何是这样，但是仔细一算好像也不对呀，整个数组所占的字节数不是20吗，这里是14呀？
- 要知道，编译器对于一块地址的表示形式是以十六进制的形式，所以我们计算出的差值应该再转换为十进制才对，那么14转换为十进制后刚好就是20，不清楚规则的同学可以去了解一下十六进制转十进制
3、数组指针的使用【⭐】
讲了这么多后，这个数组指针到底有什么用呢？
1.数组指针在一维数组的使用场景
- 之前我们在使用函数封装一个打印数组时有着下面两种写法，一个就是使用数组做接收，一个则是使用指针做接收。因为外界所传入的都是数组名，数组名就是首元素地址
void print1(int arr[], int n)
{
int i = 0;
for (i = 0; i < n; ++i)
{
printf("%d ", arr[i]);
}
printf("\n");
}
void print2(int* arr, int n)
{
int i = 0;
for (i = 0; i < n; ++i)
{
printf("%d ", arr[i]);
}
printf("\n");
}
print1(a, sz);
print2(a, sz);
- 那在学习了【数组指针】后，我们还可以把形参写成下面这种样子
void print3(int (*p)[5], int n)
{
int i = 0;
for (i = 0; i < n; ++i)
{
printf("%d ", (*p)[i]); //a[i]
}
}
- 实参就要以下面这种形式进行传递，那此时形参p接收到的就是整个数组的地址，那么此时
*p也就取到了这个一维数组的数组名，那我们平常用数组名来访问数组中的每个元素时，都是用的arr[i]这样的形式，那么用解引用后的数组指针来访问就可以写成(*p)[i]
print3(&a, sz);
但这样不是很别扭吗？传进来数组的地址，然后再解引用获取到数组名，还不如直接传递数组名呢
- 是的，一般数组指针我们不会用在一维数组的情况下，但是我们一般直接会用数组名或者指针来接收。但数组指针在二维数组中使用的还是比较的多的
2.数组指针在二维数组的使用场景
- 下面是我们之前在使用函数封装二维数组打印的时候所需要的传参
void print4(int arr[3][5], int row, int col)
{
int i = 0;
for (i = 0; i < row; i++)
{
int j = 0;
for (j = 0; j < col; j++)
{
printf("%d ", arr[i][j]);
}
printf("\n");
}
}
int a[3][5] = { {1,2,3,4,5}, {2,3,4,5,6}, {3,4,5,6,7} };
print4(a, 3, 5);
- 那采用【数组指针】的写法也是像上面这样，但是有同学却疑惑说：传进来的不是一个二维数组吗？
void print5(int (*p)[5], int row, int col)
{
int i = 0;
for (i = 0; i < row; i++)
{
int j = 0;
for (j = 0; j < col; j++)
{
printf("%d ", *(*(p + i) + j));
}
printf("\n");
}
}
- 这一块的话我就来重点分析一下了：首先你要知道知道对于一维数组而言，它的首元素地址即为数组中第一个元素的地址，那么二维数组的首元素地址相当于什么呢？如果你仔细看过数组章节的话就可以知道为第一行的地址，此时形参
p接收到的即为第一行的地址。对于二维数组把每一行看做是一个元素，那么对于这个数组来说三行就有三个元素，那么要如何访问到每一行呢？那就是使用p + i，随着【i】的不断变化就可以取到每一行的地址 - 但是我们要访问的是二维数组中的每一个元素，那取到这一行的地址后还不够，因为我们访问数组中元素时使用的都是数组名，此时
*(p + i)也就拿到了当前的这一行的数组名，假设现在要访问第一行，那它的数组名那就是a[0]，或者是*(a + 0)，以此类推后面的几行数组名就是a[1]、a[2]。那数组名我们知道，意味着首元素地址，现在先访问第一行中的每个元素，那么首先拿到的就是【1】的地址，那要访问到后面的每一个元素首先要对地址进行一个偏移，*(p + i) + j就可以拿到每个元素的地址，那此时就简单了，再解引用*(*(p + i) + j)也就取到了当前行中的每个元素，根据数组名和指针的转换规则，即为p[i][j]
来看一下运行结果
在学习了【指针数组】和【数组指针】后，来看一下这四个指针 or 数组？
int arr[5];
int *parr1[10];
int (*parr2)[10];
int (*parr3[10])[5];
- 第一个【arr】首先和
[]结合，表明它是是一个数组，数组有五个元素，每个元素都是int类型的，说明这是一个一维数组 - 第二个【parr】首先和
[]结合，表明它是一个数组，数组的每个元素都是一个int类型的指针，说明这是一个指针数组 - 第三个【parr2】首先和
*结合，表明它是一个指针，然后往后一看，它指向一个数组，该数组有10个元素，每个元素都是int类型，说明这是一个数组指针 - 第四个【parr3】首先和
[]结合，表明它是一个数组，数组有十个元素，把parr3[10]去掉后就可以看出它的类型，是int(*)[5]，说明数组中存放着的都是数组指针，每个数组指针都指向一个存有5个元素，每个元素都是int类型的数组。最后我们判定其为数组指针数组
第四个的图示如下：
三、数组传参与指针传参
相信有很多同学对于数组传参、指针传参都是搞的稀里糊涂的
1、 一维数组传参
代码：
/*一维数组传参*/
void test(int arr[]) //ok?
{}
void test(int arr[10]) //ok?
{}
void test(int* arr) //ok?
{}
int main()
{
int arr[10] = { 0 };
test(arr);
}
解析：
- 首先来看一维数组的传参，test传进来一个arr数组名，那第一个利用
arr[]接收这是我们最常见的，没有问题✔ - 第二个和第一个类似，只是在
[]里加上了一个10，不过我们知道对于一维数组里面的数组大小声明是可以省略的，所以没有关系 - 第三个是采用
*arr的方式进行接收，那传递进来的arr为数组名，数组名是首元素地址，那给到一个指针作为接收也没什么问题
代码：
void test2(int* arr[20]) //ok?
{}
void test2(int** arr) //ok?
{}
int main()
{
int* arr2[20] = { 0 };
test2(arr2);
}
解析：
- 接下去看到我向test2传递了一个指针数组，那使用
* arr[20]合情合理 ✔ - 那么第二个
** arr是都可以呢？这点我们可以通过画图来分析，因为arr2是一个指针数组，而且里面存放的每个元素都是int类型的， 那我们传递【指针数组】的数组名过去的话，那其实就是首元素地址，即这个一级指针int*的地址，那么形参部分使用二级指针来接收也是正确的 ✔
总结：
最后总结一下一维数组传参形参可以是哪些内容
- 形参可以是数组
- 形参可以是指针
- 形参可以是一个二级指针，因为指针数组的地址可以给到二级指针做接收，因为指针数组里面存放的都是一级指针
2、 二维数组传参
代码：
/*二维数组传参*/
void test(int arr[3][5])//ok？
{}
void test(int arr[][])//ok？
{}
void test(int arr[][5])//ok？
{}
int main()
{
int arr[3][5] = { 0 };
test(arr);
}
解析：
- 接下去我们再来看看二维数组的传参，第一个无需多说。第二个的话形参这种写法是不可以的，因为二维数组必须确定它的列，也就是每行有多少个元素，但是有多少行可以不用知道❌
- 那对于第三个来说就是正确的，虽然省略了第一个
[]的数组，但是指明了列的个数，就没有关系 ✔
代码：
void test2(int* arr)//ok？
{}
void test2(int* arr[5])//ok？
{}
void test2(int(*arr)[5])//ok？
{}
void test2(int** arr)//ok？
{}
int main()
{
int arr[3][5] = { 0 };
test2(arr);
}
解析：
- 上面的代码是采取形参部分指针进行接收，上面我们有分析到，二维数组的数组名是首行的地址，那可以使用一个一级指针来接收吗？很显然是不可以的❌
- 第二个
int* arr[5]可以吗？首先你要分析看它是个什么，我们传递过来的是一个地址，那地址就要使用指针来进行接收，但是可以看到这很明显是一个指针数组，因为arr和[]先结合了，所以也是错误的❌ - 那么第三个呢？通过观察可以判断出它是一个数组指针， 接收一个二维数组第一行的地址，那肯定是不会有问题的 ✔
- 最后是一个二级指针，但是二级指针只能接收一个一级指针的地址，不过我们传递过来的是一个二维数组中某一行的地址，根本牛头不对马嘴❌
总结：
最后总结一下二维数组传参形参可以是哪些内容
- 直接用二维数组做接收
- 二维数组的数组名是首行的地址，是一个一维数组的地址，要使用数组指针来接收
3、 一级指针传参
代码：
void print(int* p, int sz)
{
int i = 0;
for (i = 0; i < sz; i++)
{
printf("%d\n", *(p + i));
}
}
int main()
{
int arr[10] = { 1,2,3,4,5,6,7,8,9 };
int* p = arr;
int sz = sizeof(arr) / sizeof(arr[0]);
//一级指针p，传给函数
print(p, sz);
return 0;
}
解析：
- 接下去我们来看看一级指针的传参，那其实这很明确，在main函数中指针指向arr数组的首元素地址，传递过去后形参部分的p也指向这个地址，那么通过解引用就访问到了数组中的每一个元素
思考：
当一个函数的参数部分为一级指针的时候，函数能接收什么参数？
- 可以直接是一个变量的地址
- 可以是一级指针
- 一维数组的数组名（数组名是首元素地址，数组中的每一个元素都是一个变量）
4、 二级指针传参
代码：
void test(int** ptr)
{
printf("num = %d\n", **ptr);
}
int main()
{
int n = 10;
int* p = &n;
int** pp = &p;
test(pp);
test(&p);
return 0;
}
解析：
- 接下去我们来看看一级指针的传参，那其实这很明确，在main函数中指针指向arr数组的首元素地址，传递过去后形参部分的p也指向这个地址，那么通过解引用就访问到了数组中的每一个元素
思考：
当一个函数的参数部分为二级指针的时候，函数能接收什么参数？
- 可以直接是一个一级指针的地址
- 可以是二级指针
- 指针数组的数组名（数组名是首元素地址，数组中的每一个元素都是一个一级指针）
四、总结与提炼
最后来总结一下本文呢指针数组与数组指针
- 【指针数组】：它是一个数组，数组里存放的每一个元素都是指针类型，例：
int* arr[10] - 【数组指针】：它是一个指针，指针指向一个数组的首元素地址，可以通过指针的偏移量来找到数组中的每一个元素，例：
int (*p)[10] - 【数组与指针传参】：
- 一个形参为二级指针的函数可以接收指针数组的首元素地址，因为数组中的每一个元素都是一个一级指针
- 一个形参为数组指针的函数可以接收二维数组的首元素地址，因为二维数组的首元素即为第一行，是一个一维数组，数组指针可以指向一个一维数组的首元素地址
