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

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

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

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

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

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

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

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

int *p1[5]；
int (*p2)[5]；

首先，对于语句“int*p1[5]”，因为“[]”的优先级要比“*”要高，所以 p1 先与“[]”结合，构成一个数组的定义，数组名为 p1，而“int*”修饰的是数组的内容，即数组的每个元素。也就是说，该数组包含 5 个指向 int 类型数据的指针，如图 1 所示，因此，它是一个指针数组。

                                       图1 

其次，对于语句“int(*p2)[5]”，“()”的优先级比“[]”高，“*”号和 p2 构成一个指针的定义，指针变量名为 p2，而 int 修饰的是数组的内容，即数组的每个元素。也就是说，p2 是一个指针，它指向一个包含 5 个 int 类型数据的数组，如图 2 所示。很显然，它是一个数组指针，数组在这里并没有名字，是个匿名数组。

                                                               图2 

由此可见，对指针数组来说，首先它是一个数组，数组的元素都是指针，也就是说该数组存储的是指针，数组占多少个字节由数组本身决定；而对数组指针来说，首先它是一个指针，它指向一个数组，也就是说它是指向数组的指针，在 32 位系统下永远占 4 字节，至于它指向的数组占多少字节，这个不能够确定，要看具体情况。
 

数组指针 (*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;
}
 

最后，从上文来看：

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

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

了解指针数组和数组指针二者之间的区别之后，继续来看下面的示例代码：

int arr[5]={1，2，3，4，5};
int (*p1)[5] = &arr;
/*下面是错误的*/
int (*p2)[5] = arr;

不难看出，在上面的示例代码中，&arr 是指整个数组的首地址，而 arr 是指数组首元素的首地址，虽然所表示的意义不同，但二者之间的值却是相同的。那么问题出来了，既然值是相同的，为什么语句“int(*p1)[5]=&arr”是正确的，而语句“int(*p2)[5]=arr”却在有些编译器下运行时会提示错误信息呢（如在 Microsoft Visual Studio 2010 中提示的错误信息为“a value of type"int*"cannot be used to initialize an entity of type"int(*)[5]"”）？

其实原因很简单，在 C 语言中，赋值符号“=”号两边的数据类型必须是相同的，如果不同，则需要显示或隐式类型转换。在这里，p1 和 p2 都是数组指针，指向的是整个数组。p1 这个定义的“=”号两边的数据类型完全一致，而 p2 这个定义的“=”号两边的数据类型就不一致了（左边的类型是指向整个数组的指针，而右边的数据类型是指向单个字符的指针），因此会提示错误信息。

目录

• 一.使用数组下标遍历数组
  • 1.计算数组元素个数
  • 2.通过下标遍历数组
• 二.使用数组首地址偏移遍历数组
• 三.使用指针遍历数组
• 四.猜你喜欢

零基础 C/C++ 学习路线推荐 : C/C++ 学习目录 >> C 语言基础入门

一.使用数组下标遍历数组

数组中的每个元素都有一个序号，这个序号从 0 开始，称为下标 index，例如，a[0] 表示第 1 个元素，a[3] 表示第 4 个元素。数组是一个整体，它的内存是连续的，内存示意图：

1.计算数组元素个数

计算数组元素个数示例如下：

int arr[] = {1,2,3,4,5};
int len = sizeof(arr)/sizeof(arr[0]);  //正确的计算方式
int len = sizeof(arr);                 //错误的结算方式

2.通过下标遍历数组

/************************************************************************/
//@Author:猿说编程
//@Blog(个人博客地址): www.codersrc.com
//@File:C语言教程 - C语言 使用指针遍历数组
//@Time:2021/06/18 08:00
//@Motto:不积跬步无以至千里，不积小流无以成江海，程序人生的精彩需要坚持不懈地积累！
/************************************************************************/

#include<stdlib.h>
#include<stdio.h>
void main()
{
    int arr[5] = { 10,20,30,40,50 };
    int len = sizeof(arr) / sizeof(arr[0]);//计算数组长度
    for (int i = 0; i < len; i++)
    {
        printf("根据下标索引值循环：数组下标：%d 对应的元素地址是： %d 对应的元素的值是： %d\n", i,&arr[i],arr[i]);
    }
    system("pause");
}
/*
输出：
根据下标索引值循环：数组下标：0 对应的元素地址是： 1278408520 对应的元素的值是： 10
根据下标索引值循环：数组下标：1 对应的元素地址是： 1278408524 对应的元素的值是： 20
根据下标索引值循环：数组下标：2 对应的元素地址是： 1278408528 对应的元素的值是： 30
根据下标索引值循环：数组下标：3 对应的元素地址是： 1278408532 对应的元素的值是： 40
根据下标索引值循环：数组下标：4 对应的元素地址是： 1278408536 对应的元素的值是： 50
请按任意键继续. . .
*/

二.使用数组首地址偏移遍历数组

数组是一个整体，它的内存是连续的，那么我们可以直接通过首地址（数组名默认就是首地址）偏移来达到数组遍历的效果，内存示意图：

int arr[] = {1,2,3,4,5};
int value0 = *(arr);     //arr默认指向数组的首地址，获取数组第一个元素的值
int value1 = *(arr + 1); //数组首地址偏移 +1 ，获取数组第二个元素的值
int value2 = *(arr + 2); //数组首地址偏移 +2 ，获取数组第三个元素的值
int value3 = *(arr + 3); //数组首地址偏移 +3 ，获取数组第四个元素的值

当知道数组元素地址之后，可以直接通过 * 获取该地址对应的值，使用数组首地址偏移遍历数组，示例代码如下：

/************************************************************************/
//@Author:猿说编程
//@Blog(个人博客地址): www.codersrc.com
//@File:C语言教程 - C语言 使用指针遍历数组
//@Time:2021/06/18 08:00
//@Motto:不积跬步无以至千里，不积小流无以成江海，程序人生的精彩需要坚持不懈地积累！
/************************************************************************/

#include<stdlib.h>
#include<stdio.h>
void main()
{
    int arr[5] = { 10,20,30,40,50 };
    int len = sizeof(arr) / sizeof(arr[0]);//计算数组长度
    for (int i = 0; i < len; i++)
    {
        printf("根据下标索引值循环：数组下标：%d 对应的元素地址是： %d 对应的元素的值是： %d\n", i,arr+i,*(arr + i));
    }
    system("pause");
}
/*
输出：
根据下标索引值循环：数组下标：0 对应的元素地址是： 1619000120 对应的元素的值是： 10
根据下标索引值循环：数组下标：1 对应的元素地址是： 1619000124 对应的元素的值是： 20
根据下标索引值循环：数组下标：2 对应的元素地址是： 1619000128 对应的元素的值是： 30
根据下标索引值循环：数组下标：3 对应的元素地址是： 1619000132 对应的元素的值是： 40
根据下标索引值循环：数组下标：4 对应的元素地址是： 1619000136 对应的元素的值是： 50
请按任意键继续. . .
*/

三.使用指针遍历数组

使用指针遍历数组实际上也是通过地址偏移，和上面的数组首地址偏移遍历数组类似：

• 1.首先通过指针指向一个数组的首地址；
• 2.然后通过地址偏移，来获取对应地址的值，当知道数组元素地址之后，可以直接通过 * 获取该地址对应的值；

示例代码如下：

/************************************************************************/
//@Author:猿说编程
//@Blog(个人博客地址): www.codersrc.com
//@File:C语言教程 - C语言 使用指针遍历数组
//@Time:2021/06/18 08:00
//@Motto:不积跬步无以至千里，不积小流无以成江海，程序人生的精彩需要坚持不懈地积累！
/************************************************************************/

#include<stdlib.h>
#include<stdio.h>
void main()
{
    int arr[5] = { 10,20,30,40,50 };
    int* p = arr;  //定义一个空指针
    int len = sizeof(arr) / sizeof(arr[0]);//计算数组长度
    //int value1 = *p++; // int value1 = arr[1];
    //int value2 = *p++; // int value2 = arr[2];
    //int value3 = *p++; // int value3 = arr[3];
    //int value4 = *p++; // int value4 = arr[4];
    for (int i = 0;i<len;i++)
    {
        printf("根据指针偏移循环：数组下标：%d 对应的元素地址是： %d 对应的元素的值是： %d\n", i, p, *p);
        p++; //地址偏移+1，等价偏移到下一个元素地址
    }
    system("pause");
}
/*
输出：
根据指针偏移循环：数组下标：0 对应的元素地址是： 663747608 对应的元素的值是： 10
根据指针偏移循环：数组下标：1 对应的元素地址是： 663747612 对应的元素的值是： 20
根据指针偏移循环：数组下标：2 对应的元素地址是： 663747616 对应的元素的值是： 30
根据指针偏移循环：数组下标：3 对应的元素地址是： 663747620 对应的元素的值是： 40
根据指针偏移循环：数组下标：4 对应的元素地址是： 663747624 对应的元素的值是： 50
请按任意键继续. . .
*/

四.猜你喜欢

1. 安装 Visual Studio
2. 安装 Visual Studio 插件 Visual Assist
3. Visual Studio 2008 卸载
4. Visual Studio 2003/2015 卸载
5. C 语言格式控制符/占位符
6. C 语言逻辑运算符
7. C 语言三目运算符
8. C 语言逗号表达式
9. C 语言 sizeof 和 strlen 函数区别
10. C 语言 strcpy 和 strcpy_s 函数区别
11. C 语言 memcpy 和 memcpy_s 区别
12. C 语言 数组定义和使用
13. C 语言 数组遍历
14. C 语言 数组排序 – 冒泡法排序
15. C 语言 数组排序 – 选择法排序
16. C 语言 数组排序 – 插入法排序
17. C 语言 数组排序 – 快速法排序
18. C 语言 数组下标越界
19. C 语言 数组内存溢出
20. C 语言 数组下标越界和内存溢出区别
21. C 语言 二维数组定义和使用
22. C 语言 二维数组行数和列数计算
23. C 语言 指针声明和定义
24. C 语言 指针 p++ / p–
25. C 语言 p++/§++/_(p++)/_p++
26. C 语言 使用指针遍历数组

未经允许不得转载：猿说编程 » C 语言 使用指针遍历数组

目录

1.数组元素的访问

2.通过指针访问数组

2.1 通过指针访问一维数组

2.2 通过指针访问二维数组

2.2.1 指向元素的指针

2.2.2 指向每一行的指针（指针数组方式）

2.2.3 指向整个数组的指针（数组指针方式）

3 总结

1.数组元素的访问

       数组中的各元素在内存中是连续分布的，要想访问数组中某一元素，那么就必须知道其地址。

       在一维数组中，数组A的元素A[i]的地址&A[i]=A+L*i,其中A为数组的标识符（数组名），也可以用A来代表数组的首地址，L为数组A的数据类型，由此可见，对于一维数组，只需要知道数据类型大小和索引i，就可以知道A[i]的地址，从而就可以访问A[i]了，这也是为什么一维数组的定义可以不指定数组大小，也不会妨碍数组元素的访问。

       二维数组，实际上也是一维数组，只不过这个一维数组的每个元素都是一个一维数组。因此，将二维数组的每一行看做一个元素，很容易可以知道二维数组中各元素在内存中是按行优先进行连续存储的，如定义数组A[3][4]，那么它在内存中的存储情况如下：

            

        由此也可得到二维数组中元素A[i][j]的地址为&A[i][j]=A+L*（C*i+j），其中A为二维数组A的标识符（数组名），也就是数组的首地址，L为数组元素的数据类型，C为二维数组的列数。由此可见，要知道二维数组中某一元素的地址，就必须知道数据类型大小以及二维数组的列数，这样最终才能实现对二维数组元素的访问，这也是为什么二维数组的定义必须指定列数。

2.通过指针访问数组

       在理解访问数组的指针之前，我们不得不先理解另一个问题：如果定义一个数组A，按前面所说，A就是数组第一个元素的首地址，那么A+1是什么意思呢？我在第一次遇到这个问题的时候，第一反应是A既然表示的是地址，那么A+1自然就是地址+1了呀！然而事实并非如此，我们先来做个测试如图所示：

                                          

       根据测试可知，a+1并非就是a数值上加1，a+2也并非是a数值上加上2，他们实际上两两之间加的是4，即是sizeof(int)，而*a=a[0]=1,*(a+1)=a[1]=2.....由此可以知道，a+i实际上就是a的第i个元素的地址，这与前面&A[i]的地址计算是相匹配的。

       而对于二维数组来说，道理其实是一样的，不过二维数组的元素A[0]表示第一行，A[1]表示第二行......因此，二维数组中A是数组的首地址，也就是第0行A[0]的行首地址，A+1就是第1行A[1]的行首地址，.....，A+i就是第i行A[i]的行首地址了....

      

2.1 通过指针访问一维数组

 一维数组指针的定义方式如下：

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

       这里定义了一个指针变量p，它指向一个整型变量，而a实际上也就是a的第一个元素a[0]的地址，因此p就指向了数组的第一个元素a[0]。 那么p+1等于什么呢？实际上，p+1在数值上也就等于a+1，因此，p+1其实就是a[1]的地址，p+i就是a[i]的地址，这样，就可以通过*(p+i)来访问a[i]的值了。如图所示：

                                           

      由此可以得出，对于一维数组的数组指针p，数组名p实际上是指向数组第一个元素的指针，即p为int *类型，由于其指向int型数据，因此(p+i)就相当于在p的基础上偏移了i*sizeof(int)的地址大小，就等于数组第i个元素的地址(i=0,1,2....)。

2.2 通过指针访问二维数组

2.2.1 指向元素的指针

        这种办法可以说是最直接的办法了，定义方式如下：

int a[3][4]={{1,2,3,4},{5,6,7,8},{9,10,11,12}};
int *p=&a[0][0];

        在这种定义方式下，对于数组元素的访问就需要一个个元素往后推，结合本文开头所说的，二维数组是按行优先存储的，第i行第j列元素实际上是整个二维数组中的第i*c+j个元素，其中c为二维数组的列数，相对于第一个元素，第i*c+j个元素的地址偏移量为4*(i*c+j)，而由于p为int指针，p+x的地址偏移量为p+4*x，因此a[i][j]=*(p+i*c+j)。

2.2.2 指向每一行的指针（指针数组方式）

        这种方式是定义指针来指向二维数组的某一行，定义方式如下：

int a[3][4]={{1,2,3,4},{5,6,7,8},{9,10,11,12}};
int *p=a[0];

       这里可能会有些迷惑了，为什么这里的指针变量p是指向的a[0]呢？而不能让p指向a呢？

       实际上，前面说过，二维数组实际上是一维数组中每个元素都为一个一维数组，那么此时定义了a[3][4]，a代表什么呢？一定要知道，不管数组a是几维的，它实际上都是一维的，a一定是数组第一个元素的地址，这里的第一个元素是指的将n维数组看做一维数组后的第一个元素。因此，在a[3][4]中，将a看做一维数组后它的每一个元素实际上是每一行，因此如果让指针变量p指向a，就相当于让p指向第0行，而这里的第0行并不是整形变量，因此不能让p指向a；

       而如果让p指向a[0]，实际上就相当于指向a[0]的第一个元素，也就是a[0][0]了，此时的a[0][0]是整形变量，因此让p指向a[0]是可以的，当然，也可以让p指向a[1]、a[2].....如果让p指向第i行，那么此时的p+j就相当于是一维数组中第j个元素的地址了，即p+j就指向了a[i][j]。

       这样看来，对于有r行的二维数组，就需要定义r个指针指向每一行，这样其实就可以定义一个装有r个指针的数组，其中每一个指针分别指向二维数组的每一行，定义方式如下：

int a[3][4]={{1,2,3,4},{5,6,7,8},{9,10,11,12}};
int *p[3];

for(int i=0;i<3;i++)p[i]=a[i];

       在这种定义方式下，p[i]即指向数组的第i行，也就是a[i][0]，知道了a[i][0]的地址，要想访问a[i][j]，地址即是a[i][0]+4*j，这里由于p[i]是int型的指针变量，因此刚好就等于p[i]+j，即a[i][j]=*(p[i]+j)。这就是一种定义指向二维数组的指针的方式，这里的p是以指针作为元素的数组，也就是指针数组。

       值得注意的是，这种方法必须知道二维数组的行数。

2.2.3 指向整个数组的指针（数组指针方式）

       这种方式是定义指针来指向整个数组，定义方式如下：

int a[3][4]={{1,2,3,4},{5,6,7,8},{9,10,11,12}};
int (*p)[4]=a;

       那么这里的p是什么意思呢？如果看不懂(*p)[4]，那就把*p用b去替换掉，就成了b[4]，这里的b就很明显了，就是一个有4个元素的数组的首地址，那么这里的p的含义也就不难得出了：指向一个有四个元素的数组的首地址，尤其需要注意的是，这里p是指向首地址，并非就是首地址，*p才是首地址，也就是指向第一个元素，因此这里的p也就是指向指针的指针。在int (*p)[4]=a中，p就是指向了第一个含四个元素的数组的首地址，也就是p指向a的首地址也就是a[0]，*p指向a[0]的首地址也就是a[0][0]，要访问a[0][0]，就就是*(*p)了；

       既然p是指向一个有四个元素的数组首地址的指针，那么p+i呢？*p+i呢？要分析清楚这个问题，我们还是参考b[4]，前面说过，这里的p是指向首地址的指针，因此p+i就对应了&b+i,因此p+i就指向了&b+i所在的位置；*p是b的首地址，指向b的第一个元素，*p+i就对应了b+i，因此*p+i就指向了b+i所在的位置。

       对于p+i，我们来看看&b+i和&b之间偏移了多少:

      可以看到，&b+1偏移了16个字节，&b+2偏移了32个字节，而16个字节刚好就是数组b的大小，因此&b+i实际上偏移的地址为i*sizeof(b)=i*c*sizeof(int)。也就是说p+i会跳过整个包含四个整型元素的数组指向下一个包含四个元素的数组，回到a[3][4]中，p指向的是a[0]，那么p+1就指向a[1]，p+i就指向a[i]了，因此，p+i偏移i个b数组大小的地址，也就是指向二维数组的第i行。

        而对于*p+i，就比较简单了，可以看做*p=b，那么*p+i也就是b+i，即是第i个元素的地址，因此也可得出*p+i指向当前有四个元素的数组的第i个元素。

       好了，那么我们要是想访问数组中的a[i][j]怎么办呢？前面说过，要访问数组中的元素，必须先得到其地址，对于a[i][j]，它是a数组中第i行的子数组中的第j个元素，综合上面分析的，p+i即指向了数组a的第i行，*(p+i)就是该行的首地址，也就是指向了a[i][0]，而对于a[i]这个一维数组的第j个元素当然就是a[i]+j，也就是*(p+i)+j了，因此，a[i][j]的地址就是*(p+i)+j，a[i][j]=*(*(p+i)+j)。

3 总结

      综合以上分析，总结一下用指针访问数组元素的方法(以数组a为例)：