数组指针与指针数组解析-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_30823021/article/details/86650647

转自：https://blog.youkuaiyun.com/u013719339/article/details/80563247

首先，理解一下数组指针和指针数组这两个名词：

“数组指针”和“指针数组”，只要在名词中间加上“的”字，就知道中心了——

数组的指针：是一个指针，什么样的指针呢？指向数组的指针。

指针的数组：是一个数组，什么样的数组呢？装着指针的数组。

然后，需要明确一个优先级顺序：()>[]>*，所以：

(*p)[n]：根据优先级，先看括号内，则p是一个指针，这个指针指向一个一维数组，数组长度为n，这是“数组的指针”，即数组指针；

*p[n]：根据优先级，先看[]，则p是一个数组，再结合*，这个数组的元素是指针类型，共n个元素，这是“指针的数组”，即指针数组。

根据上面两个分析，可以看出，p是什么，则词组的中心词就是什么，即数组“指针”和指针“数组”。

数组指针 (*p)[n]

数组指针：是指针——指向数组的指针。

看下面的例子进行理解：


 
 
   
   
    
    
   
   
   
   
    
    
     
     #include "stdafx.h"
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     int main()
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     {
    
    
   
   

   
   
    
    
   
   
   
   
    
    	
     
     //一维数组
    
    
   
   

   
   
    
    
   
   
   
   
    
    	
     
     int a[
     
     5] = { 
     
     1, 
     
     2, 
     
     3, 
     
     4, 
     
     5 };
    
    
   
   

   
   
    
    
   
   
   
   
    
    	
     
     //步长为5的数组指针，即数组里有5个元素
    
    
   
   

   
   
    
    
   
   
   
   
    
    	
     
     int (*p)[
     
     5];
    
    
   
   

   
   
    
    
   
   
   
   
    
    	
     
     //把数组a的地址赋给p，则p为数组a的地址，则*p表示数组a本身
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     	p = &a;
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
    	
     
     //%p输出地址, %d输出十进制
    
    
   
   

   
   
    
    
   
   
   
   
    
    	
     
     //\n回车
    
    
   
   

   
   
    
    
   
   
   
   
    
    	
     
     //在C中，在几乎所有使用数组的表达式中，数组名的值是个指针常量，也就是数组第一个元素的地址，它的类型取决于数组元素的类型。
    
    
   
   

   
   
    
    
   
   
   
   
    
    	
     
     printf(
     
     "%p\n", a); 
     
     //输出数组名，一般用数组的首元素地址来标识一个数组，则输出数组首元素地址
    
    
   
   

   
   
    
    
   
   
   
   
    
    	
     
     printf(
     
     "%p\n", p); 
     
     //根据上面，p为数组a的地址，输出数组a的地址
    
    
   
   

   
   
    
    
   
   
   
   
    
    	
     
     printf(
     
     "%p\n", *p); 
     
     //*p表示数组a本身，一般用数组的首元素地址来标识一个数组
    
    
   
   

   
   
    
    
   
   
   
   
    
    	
     
     printf(
     
     "%p\n", &a[
     
     0]); 
     
     //a[0]的地址
    
    
   
   

   
   
    
    
   
   
   
   
    
    	
     
     printf(
     
     "%p\n", &a[
     
     1]); 
     
     //a[1]的地址
    
    
   
   

   
   
    
    
   
   
   
   
    
    	
     
     printf(
     
     "%p\n", p[
     
     0]); 
     
     //数组首元素的地址
    
    
   
   

   
   
    
    
   
   
   
   
    
    	
     
     printf(
     
     "%d\n", **p); 
     
     //*p为数组a本身，即为数组a首元素地址，则*(*p)为值，当*p为数组首元素地址时，**p表示首元素的值1
    
    
   
   

   
   
    
    
   
   
   
   
    
    	
     
     printf(
     
     "%d\n", *p[
     
     0]); 
     
     //根据优先级，p[0] 表示首元素地址，则*p[0]表示首元素本身，即首元素的值1
    
    
   
   

   
   
    
    
   
   
   
   
    
    	
     
     printf(
     
     "%d\n", *p[
     
     1]); 
     
     //为一个绝对值很大的负数，不表示a[1]...表示什么我还不知道
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
    	
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
    	
     
     //将二维数组赋给指针
    
    
   
   

   
   
    
    
   
   
   
   
    
    	
     
     int b[
     
     3][
     
     4];
    
    
   
   

   
   
    
    
   
   
   
   
    
    	
     
     int(*
     
     pp)[
     
     4]; 
     
     //定义一个数组指针，指向含4个元素的一维数组
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     	pp = b; 
     
     //将该二维数组的首地址赋给pp，也就是b[0]或&b[0]，二维数组中pp=b和pp=&b[0]是等价的
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     	pp++; 
     
     //pp=pp+1，该语句执行过后pp的指向从行b[0][]变为了行b[1][]，pp=&b[1]
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
    	
     
     int k;
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     	scanf_s(
     
     "%d", &k);
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
        
     
     return 
     
     0;
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     }

根据上面二维数组可以得出，数组指针也称指向一维数组的指针，所以数组指针也称行指针。

指针数组 *p[n]

指针数组：是数组——装着指针的数组。

看下面的例子进行理解：


 
 
   
   
    
    
   
   
   
   
    
    
     
     #include "stdafx.h"
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     int main()
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     {
    
    
   
   

   
   
    
    
   
   
   
   
    
    	
     
     int a = 
     
     1;
    
    
   
   

   
   
    
    
   
   
   
   
    
    	
     
     int b = 
     
     2;
    
    
   
   

   
   
    
    
   
   
   
   
    
    	
     
     int *p[
     
     2];
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     	p[
     
     0] = &a;
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     	p[
     
     1] = &b;
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
    	
     
     printf(
     
     "%p\n", p[
     
     0]); 
     
     //a的地址
    
    
   
   

   
   
    
    
   
   
   
   
    
    	
     
     printf(
     
     "%p\n", &a); 
     
     //a的地址
    
    
   
   

   
   
    
    
   
   
   
   
    
    	
     
     printf(
     
     "%p\n", p[
     
     1]); 
     
     //b的地址
    
    
   
   

   
   
    
    
   
   
   
   
    
    	
     
     printf(
     
     "%p\n", &b); 
     
     //b的地址
    
    
   
   

   
   
    
    
   
   
   
   
    
    	
     
     printf(
     
     "%d\n", *p[
     
     0]); 
     
     //p[0]表示a的地址，则*p[0]表示a的值
    
    
   
   

   
   
    
    
   
   
   
   
    
    	
     
     printf(
     
     "%d\n", *p[
     
     1]); 
     
     //p[1]表示b的地址，则*p[1]表示b的值
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
    	
     
     //将二维数组赋给指针数组
    
    
   
   

   
   
    
    
   
   
   
   
    
    	
     
     int *pp[
     
     3]; 
     
     //一个一维数组内存放着三个指针变量，分别是p[0]、p[1]、p[2]，所以要分别赋值
    
    
   
   

   
   
    
    
   
   
   
   
    
    	
     
     int c[
     
     3][
     
     4];
    
    
   
   

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

   
   
    
    
   
   
   
   
    
    
     
     		pp[i] = c[i];
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
    	
     
     int k;
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     	scanf_s(
     
     "%d", &k);
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
        
     
     return 
     
     0;
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     }

最后，从上文来看：

数组指针是一个指针变量，占有内存中一个指针的存储空间；

指针数组是多个指针变量，以数组的形式存储在内存中，占有多个指针的存储空间。

指向二维数组，取值：


 
 
   
   
    
    
   
   
   
   
    
    
     
     #include "stdafx.h"
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     int main()
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     {
    
    
   
   

   
   
    
    
   
   
   
   
    
    	
     
     /*同时指向二维数组时，引用、用数组名引用表达是相同的
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     	定义一个2行3列的二维整型数组
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     	0 1 2
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     	3 4 5
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     	输出第1行第2列的值：5*/
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
    	
     
     int a[
     
     2][
     
     3] = { {
     
     0, 
     
     1, 
     
     2}, {
     
     3, 
     
     4, 
     
     5} }; 
     
     //2行3列的二维整型数组
    
    
   
   

   
   
    
    
   
   
   
   
    
    	
     
     int(*p)[
     
     3]; 
     
     //数组指针，指向含有3个元素的一维数组
    
    
   
   

   
   
    
    
   
   
   
   
    
    	
     
     int *q[
     
     2]; 
     
     //指针数组，一个数组内存放2个指针变量
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     	p = a;
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     	q[
     
     0] = a[
     
     0];
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     	q[
     
     1] = a[
     
     1];
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
    	
     
     //输出第1行第2列的值
    
    
   
   

   
   
    
    
   
   
   
   
    
    	
     
     printf(
     
     "%d\n", a[
     
     1][
     
     2]); 
     
     //5
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
    	
     
     printf(
     
     "%d\n", *(p[
     
     1] + 
     
     2)); 
     
     //5
    
    
   
   

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

   
   
    
    
   
   
   
   
    
    	
     
     printf(
     
     "%d\n", (*(p + 
     
     1))[
     
     2]); 
     
     //5
    
    
   
   

   
   
    
    
   
   
   
   
    
    	
     
     printf(
     
     "%d\n", p[
     
     1][
     
     2]); 
     
     //5
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
    	
     
     printf(
     
     "%d\n", *(q[
     
     1] + 
     
     2)); 
     
     //5
    
    
   
   

   
   
    
    
   
   
   
   
    
    	
     
     printf(
     
     "%d\n", *(*(q + 
     
     1) + 
     
     2)); 
     
     //5
    
    
   
   

   
   
    
    
   
   
   
   
    
    	
     
     printf(
     
     "%d\n", (*(q + 
     
     1))[
     
     2]); 
     
     //5
    
    
   
   

   
   
    
    
   
   
   
   
    
    	
     
     printf(
     
     "%d\n", q[
     
     1][
     
     2]); 
     
     //5
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
    	
     
     int k;
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     	scanf_s(
     
     "%d", &k);
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
        
     
     return 
     
     0;
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     }