[TOC]

上一站🚏我们学习了指针数组

今天来到我们的第三站🚌

寒假也不能落下学习！

今天学到了一个新的markdown语法

我是红色

1
<font color=red>我是红色</font>

数组指针

整型指针：指向整型的指针

字符指针：指向字符的指针

数组指针：指向数组的指针

1基本概念

下面哪个是数组指针呢？

指针数组和数组指针的概念很容易混淆，一定要分清楚哦！

1
2
int *p1[10];
int (*p2)[10];
  • p1是指针数组，每个元素的类型是int*
  • p2是数组指针，每个元素的类型是int(*)[10]
1
2
3
4
int (*p2)[10];
//p2先和*结合，表示p2是一个指针变量
//指向一个大小为10个整型的数组
//所以p2是数组指针

注：[ ]的优先级高于*，所以必须加上()来保证p2先和*结合

1.1代码示例

1
2
int* parr[6];
int* (*pp)[6] = &parr;

pp是一个数组指针，类型是int*(*)[6],存放的是int*类型的数组，该数组有6个元素

image-20220121115843732

一般情况下，去掉变量名，剩下的即为变量类型

如：int* (*pp)[6]去掉变量名pp，变量类型为int*(*)[6]

1
2
char arr[5];
char (*pa)[5] = &arr;

pa也是一个数组指针，变量类型为char(*)[5]，指向char类型的数组，该数组元素个数为5

1.2错误示范

你肯定会有一个疑问，变量类型为int(*)[5]的数组指针，能否指向数组元素为3或者6的数组呢？

image-20220121120616469

程序能够正常编译，但是会报出如下警告

1
warning C4048: “int (*)[5]”和“int (*)[3]”数组的下标不同

在正常编写代码的时候，我们还是得保证数组指针和原数组的元素个数一致！

2arr和&arr的区别

在进一步了解数组指针之前，我们需要了解arr和&arr的区别

当我们用%p打印arr和&arr时，会发现它们的结果是相同的

image-20220121123556204

但这能说明arr和&arr等价了吗？

并不能！

再来看看下面这串代码

image-20220121123344183

  • arr+1跳过4个字节，一个元素int的大小
  • &arr+1跳过40个字节，整个数组的大小

其实&arr和arr虽然指向的地址值相同，但是意义不同！

  • &arr表示的是数组的地址，是int(*)[10]类型
  • arr表示数组首元素的地址，是int*类型

数组的地址+1，跳过整个数组的大小

所以&arr+1和&arr的差值为40

对应的int(*p)[5]和int* p1也有不同

  • p接收的是&arr，整个数组的地址
  • p1接收arr，数组首元素的地址

3数组指针的使用

3.1打印一维数组

下面这串代码是用整型指针打印数组元素的情况

image-20220121121848890

除了整型指针外，我们可以利用数组指针打印元素

1
2
3
4
5
6
7
8
9
10
11
12
13
int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int (*p)[10] = &arr;
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", *((*p) + i));
        //*p-->arr
	}
	printf("\n");
	return 0;
}

*p等价于arr，arr+i等价于&arr[i]，对arr+i解引用就是arr[i]

image-20220121122631386

但是这种方式实际上是把简单问题复杂化了：我们本来就可以用int*指针来打印数组元素，为何要利用数组指针来多此一举呢？

所以在一维数组里面，我们一般不会这么写

3.2打印二维数组

假设我现在需要一个print函数来打印二维数组

在之前，我们一般会想到用这张方式传入二维数组

1
void print(int a[3][5], int r, int c);

当我们想用数组指针的时候，情况就有些变化了

  • 数组名是数组首元素的地址
  • 二维数组的首元素是第一行
  • 二维数组的数组名表示第一行的地址
1
2
//main函数中
print(arr,3,5);

这里prinf里面的arr就需要用数组指针来接收

该二维数组是3行5列，每一行都有5个元素，是一个int[5]的数组

对应的数组指针为int(*)[5]类型

1
void print(int(*p)[5], int r, int c)

这里的p指针指向的是二维数组第一行的地址

*p：对p直接解引用

相当于拿道了第一行元素的地址（把第一行看作数组，也就是数组的地址）

相当于是二维数组第一行首元素的地址

image-20220121130456678

  • 对(p+i)解引用，就能拿到第i行第一个元素的地址
  • *(p+i)+j第i行第j个元素的地址
  • *(*(p+i)+j)第i行第j个元素

这一部分和上篇博客指针数组的内容相似

最终的函数实现如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
void print(int(*p)[5], int r, int c)
{
	int i = 0;
	for (i = 0; i < r; i++)
	{
		int j = 0;
		for (j = 0; j < c; j++)
		{
			printf("%d ", *(*(p + i) + j));		
		}
		printf("\n");
	}
}

int main()
{
	int arr[3][5] = { {1,2,3,4,5},{2,3,4,5,6},{3,4,5,6,7} };
	print(arr,3,5);

	return 0;
}

image-20220121130656899

3.3 关于二维数组传参

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
void fun2(int **p){
    return;
}

void test03()
{
    int a[4]={1,2,3,4};
    int b[3][4]={{1,2,3,4},{5,6,7,8},{9,10,11,12}};
    int *q[3]={b[0],b[1],b[2]};
    //fun2(a);
    //fun2(&a);
    //fun2(b);
    fun2(q);

}

在2022的暑假作业day02中有这么一道题目，问的是上面4种调用方式谁位合法。
经过测试，只有最后一个是不报错的。

这里涉及到了一个我之前从来没注意过的点：二维数组不能直接用二级指针接受。在上面的2.2中其实有提到，二维数组的接受需要用对应的数组指针来接受。比如int b[3][4]对应的数组指针就是int (*p)[4]类型的。不能直接简单粗暴地用二级指针int**来接收二维数组

1
2
3
4
5
6
7
8
9
void fun3(int (*p)[4])
{
    return;
}
int main()
{
	int b[3][4]={{1,2,3,4},{5,6,7,8},{9,10,11,12}};
	func3(b);//这样才是正确的
}

4练习：判断

这一站最重要的就是区别指针数组和数组指针

4.1 int arr[5]

1
int arr[5];

arr是一个整型数组，有5个元素，每个元素是int类型的

4.2 int*parr[10]

1
int*parr1[10];

parr1是一个数组，数组有10个int*类型的元素

所以parr1是指针数组

4.3 int (*parr2)[10]

1
int(*parr2)[10];

parr2和*结合，表示parr2是一个指针

去掉parr2即为它的变量类型int(*)[10]

所以parr2是一个数组指针

4.4 int(*parr3[10])[5]

1
int(*parr3[10])[5];

[]的优先级高于*

parr3先和[]结合，说明parr3是一个数组

该数组有10个元素，每一个元素都是一个数组指针，类型是int(*)[5]

该数组指针指向的数组有5个int类型的元素

image-20220121131906210

结语

第三站数组指针到这里就结束啦！

下一站🚌是：数组传参和指针传参

敬请期待哦~

如果这篇博客对你有帮助，点个赞再走吧😘