一、什么是指针数组和数组指针

1. 指针数组：顾名思义，存放指针的数组。是指一个数组里面装着指针，也即指针数组是一个数组，数组中的每个元素都是指针。

定义形式：int *a[10]。

说明：[]的优先级高于*，该定义形式可以理解为：int * (a[10])；括号里面说明a是一个数组，包含了10个元素，括号外面说明每个元素的类型为int *。

如图所示：

下面是个简单的例子

#include <stdio.h>
int main()
{
    //定义三个整型数组
	int a[5] = { 1,2,3,4,5 };
	int b[5] = { 6,4,8,3,1 };
	int c[5] = { 2,5,8,6,1 };
    //定义一个存放指向整型变量的指针的数组arr
    int* arr[] = { a,b,c };
    //通过接引用打印出三个一维数组的元素
	for (int i = 0; i < 3; i++)
	{
		for (int j = 0; j < 5; j++)
        {
		    printf("%d ", *(arr[i]+j));
	    }
        printf("\n");
    }
	return 0;
}

结果如下：

      1 2 3 4 5

      6 4 8 3 1

      2 5 8 6 1

以上对arr解引用的方式有很多，它们都是等价的，我们来举个例子：

#include<stdio.h>
int main()
{
	int i = 0;
	int a[3][4] = { {1,2,3,4} ,{5,6,7,8} ,{9,10,11,12} };//定义一个二维数组
	int* pa[3];//定义一个指针数组
	for (i = 0; i < 3; i++)//给指针数组赋值
		pa[i] = a[i];
    printf("指针数组的内容为:\n");
	for (i = 0; i < 3; i++)//打印出指针数组的内容
	{
		int j;
		for (j = 0; j < 4; j++)
			printf("%d ", *(*(pa + i) + j));
		printf("\n");
	}
    //以下均为不同方式的解引用操作
    printf("不同解引用操作的结果为:\n");
	printf("%d,%d\n", a[1][1], *(pa[1] + 1));
	printf("%d,%d\n", a[1][1], *(*(pa+1) + 1));
	printf("%d,%d\n", a[1][1], (*(pa + 1))[1]);
	printf("%d,%d\n", a[1][1], pa[1][1]);
    return 0;
}

结果如下所示：

指针数组的内容为:

1 2 3 4
5 6 7 8
9 10 11 12

不同解引用操作的结果为:

6,6
6,6
6,6
6,6

从以上例子可看出解引用有多种方式，它们的等价形式如下：

*( pa[i] + j ) //等价于 *( a[i] + j )

*( *(p+i) + j ) //等价于 *( *(a+j) + j )

( *(p+i) )[ j ] //等价于( *(a+i) )[ j ]

p[ i ][ j ] //等价于 a[i][j]

补充（1）：指针数组还可以和字符串数组相结合使用，请看下面的例子：

#include <stdio.h>
int main(){
    char *str[3] = {"lirendada","C语言","C Language"};
 
    printf("%s\n%s\n%s\n", str[0], str[1], str[2]);
    return 0;
}

结果如下：

lirendada

c语言

C Language

需要注意的是，字符数组 str 中存放的是字符串的首地址，不是字符串本身，字符串本身位于其他的内存区域，和字符数组是分开的。

也只有当指针数组中每个元素的类型都是char *时，才能像上面那样给指针数组赋值，其他类型不行。

补充（2）：二维数组与指针数组的区别

char *p1[]={"lirendada","C","C++"};
char p2[][8]={"liren","C","C++"};

*p1，*(p1+1)，*(p1+2)：所指向的字符串常量是不规则长度的，且sizeof(p1)=12。

p2[0]，p2[1]，p2[2]所指向的字符串都是一定长度的，且sizeof(p2)=24。

2. 数组指针：顾名思义，是指一个指向数组的指针，本质上还是一个指针，只不过是指向数组而已。

定义形式：int (*p)[10]; 其中，由于[]的优先级高于*,所以必须添加(*p)。

说明：括号中的*表明 p 是一个指针，该指针变量保存的是一个数组的首地址,它指向一整个数组()，数组的类型为int[10]，这正是 a 所包含的每个一维数组的类型。

在32位系统下任何类型的指针所占内存大小都为4个字节，至于它指向的数组占多少字节，具体要看数组的大小。总之，数组指针即为“指向数组的大小”。

如图所示：

举个栗子：

    int arr[10]={1,2,3,4,5,6,7,8,9,10};
    int (*p)[10]=&arr;//数组的地址要存起来
    //上面的p就是数组指针
    int i=0;
    for(i=0;i<10;i++)
    {
        printf("%d ",*(*p+i));//第一种方法打印数组
    }
    printf("\n");
    for(i=0;i<10;i++)
    {
        printf("%d ",(*p)[i]);//第二种方法打印数组
    }
    printf("\n");

数组指针一般是用在二维数组中，例如：

//参数是指针的形式
void print(int(*p)[5],int x,int y)
{
    int i=0;
    for(i=0;i<x;i++)
    {
        int j=0;
        for(j=0;j<y;j++)
        {
            printf("%d ",*(*(p+i)+j));//*(p+i)=p[i],所以*(*(p+i)+j)=p[i][j]
        }
        printf("\n");
    }
}

int a[3][5]={{1,2,3,4,5},{2,3,4,5,6},{3,4,5,6,7}};
print(a,3,5);
//1 2 3 4 5
//2 3 4 5 6
//3 4 5 6 7
//此处将每一行看成一个元素，利用数组指针将二维数组看成一维数组int [5]

一维数组指针和二维数组指针相关区别

一、指向一维数组的指针变量设一维数组为a[n]

定义方法：* 指针变量名即 * P
这个p一般指向的一维数组的首地址，即p=a，或者p=&a[0]；p,a,&a[0]均指向同一单元，它们是数组a的首地址，也是0号元素a[0]的首地址。p+1,a+1,&a[1]均指向1号元素a[1]。类推可知p+i,a+i,&a[i]。

二、指向二维数组的指针变量设二维数组为a[m][n]

定义方法：(*指针变量名)[长度]即（*P）[n]
“长度”表示二维数组分解为多个一维数组时，一维数组的长度，也就是二维数组的列数。

关于指针数组，我们大致遵循以下规则：

（1）访问数组元素，要么用下标法 []，要么用指针*.

（2）一维数组用一个下标，二维数组用两个下标

（3）指针指向数组元素时，指针表示数组元素的地址，用 * 对这个地址运算就求出了这个地址（即数组元素）的值

（4）指针数组指向二维数组时，因为它本身是个指向数组的指针，所以它的内层每加一，就相当于下一个数组