C语言 #指针数组 #数组指针 #数组参数、指针参数

在前面我们学过字符数组、整型数组等，字符数组即数组中的元素是char 类型，char ch [10]; 则表示数组ch 中有10个为char 类型的元素；整型数组即数组中的元素是 int 类型，int arr [10] ; 则表示数组arr 中有10个为int 类型的元素;（假设有10个元素）显然指针数组就应该其数组有10个元素为指针，即 int* p1[10] ; 则说明数组 p1中有10个为 Int * 类型的元素；

在 int * p1[10] ; 中p1 先与 [10] 结合，说明 p1 为数组，而其前面的int* 代表着数组p1 中的元素为 int * 类型；同理数组的元素也可以是 char * 、short * 、 long * 、 float * 、 double * 等类型。

2、指针数组有什么用呢？

举例：利用指针数组模拟实现二维数组

注：此处并不为二维数组，因为二维数组在内存中是连续存放的；而这里的模拟的二维数组并不是连续存放在一块空间中；

代码如下：

#include<stdio.h>

int main()
{
	int arr1[] = { 1,1,1,1,1 };
	int arr2[] = { 2,2,2,2,2 };
	int arr3[] = { 3,3,3,3,3 };

	int* parr[3] = { arr1,arr2,arr3 };
	
	int i = 0;
	int j = 0;
	for (i = 0; i < 3; i++)
	{
		for (j = 0; j < 5; j++)
		{
			printf("%d ", *(*(parr + i) + j)); //利用地址
			//printf("%d ", parr[i][j]);//利用下标进行访问
		}
		printf("\n"); //打印完一行就换行 
	}
	return 0;
}

代码运行结果如下：

分析：arr1 、arr2 、 arr3 是整型数组；因为数组名代表着数组的首元素地址，所以数组parr 中的元素为数组名，本质就是 int* 类型的元素；所以指针数组parr 的类型为 int* ; 数组名可以看作数组名，也可以当作数组首元素的地址；故而想要访问指针数组中存放的数组名中的元素便有两种方式，一是通过数组的下标进行访问；二是利用地址的方式进行访问；

一：

利用下标访问数组parr 中的元素 --> parr [i] ; parr数组中的元素就是数组名，即 parr[0] 相当于 arr1, parr[1] 相当于 arr2 , parr [2] 相当于 arr3 ；那么访问arr1 arr2 arr3 中的元素也可以利用下标的形式，即得到 parr [i][j] ;

二：

利用地址的方式来访问 parr 中的元素--> 数组名parr 代表着数组parr中首元素的地址，即指针，可以利用指针+1 来跳过一个元素再解引 --> *( parr + i )，所以得到了数组parr 中的元素；然而parr 中的数组名又可以看作其首元素地址 --> * (*( parr + i ) + j) ;

二、数组指针

1、数组指针的定义

之前我们学过整型指针： int * p1，* 代表着变量 p1 为指针变量，指针p1 指向对象的类型为 int ; 字符指针： char * p2， * 代表着变量 p2 为指针变量，指针 p2 指向对象的类型为char ; 浮点型指针： float * p3 ,* 代表着变量 p3 为指针变量，指针变量p3 指向对象的类型为 float ;等，那么数组指针呢？应该就是指向数组的一个指针变量；

在学习数组的时候，曾说过数组的类型，详情可以戳此链接：http://t.csdnimg.cn/DTudO

注：例如： int arr[10] ; --> 整型数组arr的类型为 int [10] ; 即去掉数组名剩下的为数组的类型；

如果将以上例子中的数组arr 的地址存放起来 --> int (*p) [10] = &arr;

* 与变量 p 结合代表着变量p 为指针变量，int [10] 为数组arr 的类型，代表着数组有10 个为int 类型的元素;

注：这里的 [ ] 的优先级高于 * ，所以要用（）将 *p 括起来，以保证 p 先与 * 结合。

2、数组名与 &数组名的区别

eg . int arr [10];

显然，数组名arr 代表着其首元素的地址；

数组名不是为首元素地址吗？为什么此处 sizeof(arr) 的结果为40 byte? 因为数组名不能只能理解为其首元素地址；

数组名通常表示的都是其首元素的地址；

但是有两个例外：

1、sizeof(数组名) ，这里的数组名表示整个数组，所以计算的是整个数组的大小

2、&数组名，这里的数组名表示的依然是整个数组，所以 &数组名取出的是整个数组的地址；

分析：&arr[0] 、arr 针对的是数组中的首元素地址，即此地址的类型为一个整型，也就是 int* ,那么这些地址 +1 便会跳过 4 byte;而&arr 取出来整个数组的地址，即此地址的类型为40byte ，那么&arr +1 便会跳过 40byte ;

观察代码的运行结果也可得知，0136FBD8 --> 0136FBDC 之间差距了 4byte; 而 0136FBD8--> 0136FC00 --> 十六进制差了：28 --> 十进制：2*16+8*1 = 40，单位为字节;

3、数组指针如何初始化？

注：想要存放数组的地址，指针变量类型中的[ ]里必须要标明数组的元素个数

站在数组arr 的角度来看，它有10个元素，但站在指针变量 p 的角度来看，它认为自己指向的数组里面没有元素，即为0--> 指针变量p 的类型为 int (*)[0] ；

所以初始化数组指针时，一定要标明数组元素的个数；

4、数组指针的用法

数组指针不适合用于一维数组中，至少是用到二维、三维数组之中；

例二：（常见用法）

代码如下：

#include<stdio.h>

void print(int(*p)[4], int r, int c)
{
	int i = 0;
	int j = 0;
	for (i = 0; i < r; i++)
	{
		for (j = 0; j < c; j++)
		{
			printf("%d ", *(*(p + i) + j)); //利用地址进行访问
			//printf("%d ", p[i][j]); 利用下标进行访问

		}
		printf("\n");
	}
}

int main()
{
	int arr[3][4] = { {1,2,3,4},{1,2},{1,2,3}};
	print(arr, 3, 4);//二维数组的首元素是其第一行的元素，即一维数组
	return 0;
}

代码运行结果如下：

注：二维数组数组名代表着其首元素的地址，而二维数组的首元素是其一行元素，即一维数组，所以在函数形参部分要用数组指针来接收 (当然，实参传的是二维数组，也可以用二维数组来接收)；既然形参是一维数组，即一维数组名，而一维数组名又为其首元素地址；于是乎此处便又有两种方式来访问二维数组arr 中的所有元素；一是利用数组的下标进行访问，二是利用地址进行访问；

利用数组下标进行访问： p[i][j] ；形参 int(*p)[4] 接受了实参 arr ，arr 为二维数组，其数组名代表着其第一排元素的地址即一维数组的地址，而变量 p 为指向一维数组的指针变量，即可以将p看作二维数组名arr ；那么利用数组的下标进行访问即可得到 p[i][j] ；

利用地址进行访问：*(*(p + i) + j) ；形参中变量 p为一个指向一维数组的指针变量；指针变量的类型为 int ( * )[4] ,所以 p+1 ,便会跳过此一维数组而访问到下一个一维数组（即二维数组的下一个元素）；又可以将一维数组名当作其首元素的地址，*( p + i ) 为一维数组的数组名，*( p + i) + j 代表着访问到各个元素的地址，想要得到元素就要对地址进行解引用操作，即 *(*(p + i) + j ) ;

三、根据代码区分指针数组和数组指针

int arr[5] ;

int * parr1[10] ;

int (*parr2)[10] ;

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

分析：

1、arr 与 [ ] 先结合，代表着 arr 为数组，即数组arr 有10个int 类型的元素；所以arr 是整型数组；

2、由于 [ ] 的优先级高于 * ，故而 parr1 先于 [ ] 结合，代表着parr1 为数组，即数组 parr1 有10个为 int * 类型的元素;所以 parr1 是整型指针数组；

3、( ) 将* 与 parr2 括起来，代表着parr2 先与 * 结合，代表着变量 parr2 为指针变量，指针变量 parr2 指向了有10个为 int* 元素的数组，即此数组的类型为 int (*) [10] ;所以 parr2 为数组指针；

4、由于[ ] 的优先级高于* ，所以parr3 先与 [ ] 结合，代表着parr3 为数组，即有10个为 int (*)[5] 类型的数组，所以数组 parr3 为存放数组指针的数组；所以parr3 为数组指针数组；（可以理解为二维数组）

四、数组参数、指针参数

1、一维数组传参

一维数组的数组名有两种理解方式，一是理解为数组名代表着整个数组，想要访问数组中的元素的话就用下标访问即可；二是，将一维数组名当作其首元素的地址，那么想要访问此一维数组中的元素就要利用地址进行访问；

所以形参接收形式上可以划分为两种，一是用一维数组来接受，二是利用其元素类型的指针来接收；

注：形参用一维数组来接收实参传过来的一维数组时，形参部分可以不用写数组元素的个数，但是写了也不会报错，因为编译器根本就不会用这个值；

例3：

int arr1[10] = {0} ;

若是将数组arr1传参，那么形参部分便可以写作：

int arr[ ] //形参部分用一维数组来接收，省略了数组的元素个数

int arr[10] //形参部分用一维数组来接收，并未省略了数组的元素个数

int * p //形参部分用传过来数组元素类型的指针来接收

同理，例4：

int* arr2[10] = { 0 } ;

若是将数组arr2传参，那么形参部分便可以写作：

int* arr [ ]    //形参部分用一维数组来接收，省略了数组的元素个数

int* arr [10]   //形参部分用一维数组来接收，并未省略了数组的元素个数

int** p   //形参部分用传过来数组元素类型的指针来接收；数组arr2 中的元素类型为int* ;

此处 int** p第二个 * 代表了变量p 是指针变量，即指针变量p 指向的对象类型为 int* ;

2、二维数组传参

同理，二维数组的数组名也有两种理解，一是理解为数组名代表着整个数组，想要访问数组中的元素的话就用下标访问即可；二是，将一维数组名当作其首元素的地址，只不过二维数组的首元素是其第一行的元素，那么想要访问此二维数组中的元素就要利用地址进行访问；

所以二维数组的形参接收形式上可以划分为两种，一是用二维数组来接受，二是利用此二维数组首元素（其第一行元素）的类型的指针来接收；

注：

1、形参用二维数组来接收实参传过来的二维数组时，形参部分可以不用写数组行的信息，但是写了也不会报错，因为编译器根本就不会用这个值；但是不可省略列的信息；

2、二维数组的首元素为其第一行的元素

例4：

int arr3 [3][5] = { 0 } ;

若是将数组arr3传参，那么形参部分便可以写作：

int arr[ ][5] //形参部分用二维数组来接收，省略了数组行的信息

int arr[3][5] //形参部分用二维数组来接收，没有省略了数组行的信息

int (*p) [5] //形参部分用此二维数组的首元素类型的指针来接收；

//二维数组首元素的类型为int [5] , * 代表着变量 p 为指针变量，指针变量p 的类型为 int (*) [5] ,指针变量指向的对象的类型为 int [5];