数组指针 订阅
数组指针,指的是数组名的指针,即数组首元素地址的指针。即是指向数组的指针。例:int (*p)[10]; p即为指向数组的指针,又称数组指针。 展开全文
数组指针,指的是数组名的指针,即数组首元素地址的指针。即是指向数组的指针。例:int (*p)[10]; p即为指向数组的指针,又称数组指针。
信息
外文名
array pointer
运用领域
计算机编程
本    质
指针
中文名
数组指针
源    于
编程语言,如c,c++
数组指针本质与区别
数组指针是指向数组地址的指针,其本质为指针; 指针数组是数组元素为指针的数组(例如 int *p[3],定义了p[0],p[1],p[2]三个指针),其本质为数组。数组指针的使用在某些情况下与指针数组很相似,要注意区别。
收起全文
精华内容
下载资源
问答
  • 数组指针
    万次阅读 多人点赞
    2019-09-17 16:39:06

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

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

    数组的指针:是一个指针,什么样的指针呢?指向数组的指针。

    指针的数组:是一个数组,什么样的数组呢?装着指针的数组。

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

    (*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 这个定义的“=”号两边的数据类型就不一致了(左边的类型是指向整个数组的指针,而右边的数据类型是指向单个字符的指针),因此会提示错误信息。

    更多相关内容
  • 数组的内部指针是数组内部的组织机制,指向一个数组中的某个元素。默认是指向数组中第一个元素通过移动或改变指针的位置,可以访问数组中的任意元素。...在下面的示例中,将使用这些数组指针函数控
  • php数组指针操作详解

    2021-01-20 00:44:00
    数组指针的操作: 移动数组指针的操作: Next() 向下 同时会获得当前元素的值。 Prev() 向上同时会获得当前元素的值。 End() 移动到最后一个元素单元 获得最后一个元素的值 Reset() 移动到第一个单元 获得第一个元素...
  • 数组指针函数有reset(),prev(),current(),next(),end(),key(),each() 其中reset(),prev(),current(),next(),end(),都是只与数组的值有关的函数,key()只与数组键,有关的函数,each()可以获得数组的值和键 reset...
  • 数组指针与指针数组

    2021-01-20 14:02:37
    数组指针与指针数组 数组指针: 什么是数组指针:能够指向数组的指针。 定义一个int (*p)[10],首先()的优先级高于[]所以p首先是一个指针,指向的是一个整形的一维数组,所以是数组指针数组指针是一个指针不是...
  • 本篇文章是对数组指针指针数组的区别进行了详细的分析介绍,需要的朋友参考下
  • 下面来讲讲多维数组指针的关系。与普通数组一样,使用多维数组时,实际上将其自动转换为指向该数组第一个元素的指针
  • 定义数组时,要给出数组名和数组长度,数组名可以认为是一个指针,它指向数组的第 0 个元素。在C语言中,我们将第 0 个元素的地址称为数组的首地址。以上面的数组为例,下图是 arr 的指向: 下面的例子演示了如何以...
  • 定义数组时,要给出数组名和数组长度,数组名可以认为是一个指针,它指向数组的第 0 个元素。在C语言中,我们将第 0 个元素的地址称为数组的首地址。以上面的数组为例,下图是 arr 的指向: 数组名的本意是表示...

    数组(Array)是一系列具有相同类型的数据的集合,每一份数据叫做一个数组元素(Element)。数组中的所有元素在内存中是连续排列的,整个数组占用的是一块内存。以int arr[] = { 99, 15, 100, 888, 252 };为例,该数组在内存中的分布如下图所示:

    定义数组时,要给出数组名和数组长度,数组名可以认为是一个指针,它指向数组的第 0 个元素。在C语言中,我们将第 0 个元素的地址称为数组的首地址。以上面的数组为例,下图是 arr 的指向:

    数组名的本意是表示整个数组,也就是表示多份数据的集合,但在使用过程中经常会转换为指向数组第 0 个元素的指针,所以上面使用了“认为”一词,表示数组名和数组首地址并不总是等价。初学者可以暂时忽略这个细节,把数组名当做指向第 0 个元素的指针使用即可,我们将在 VIP教程《数组和指针绝不等价,数组是另外一种类型》和《数组到底在什么时候会转换为指针》中再深入讨论这一细节。

    下面的例子演示了如何以指针的方式遍历数组元素:

     
    
    1. #include <stdio.h>
    2. int main(){
    3. int arr[] = { 99, 15, 100, 888, 252 };
    4. int len = sizeof(arr) / sizeof(int); //求数组长度
    5. int i;
    6. for(i=0; i<len; i++){
    7. printf("%d ", *(arr+i) ); //*(arr+i)等价于arr[i]
    8. }
    9. printf("\n");
    10. return 0;
    11. }

    运行结果:
    99  15  100  888  252

    第 5 行代码用来求数组的长度,sizeof(arr) 会获得整个数组所占用的字节数,sizeof(int) 会获得一个数组元素所占用的字节数,它们相除的结果就是数组包含的元素个数,也即数组长度。

    第 8 行代码中我们使用了*(arr+i)这个表达式,arr 是数组名,指向数组的第 0 个元素,表示数组首地址, arr+i 指向数组的第 i 个元素,*(arr+i) 表示取第 i 个元素的数据,它等价于 arr[i]。

    arr 是 int*类型的指针,每次加 1 时它自身的值会增加 sizeof(int),加 i 时自身的值会增加 sizeof(int) * i, 这在《C语言指针变量的运算》中已经进行了详细讲解。

    我们也可以定义一个指向数组的指针,例如:

     
    
    1. int arr[] = { 99, 15, 100, 888, 252 };
    2. int *p = arr;

    arr 本身就是一个指针,可以直接赋值给指针变量 p。arr 是数组第 0 个元素的地址,所以int *p = arr;也可以写作int *p = &arr[0];。也就是说,arr、p、&arr[0] 这三种写法都是等价的,它们都指向数组第 0 个元素,或者说指向数组的开头。

    再强调一遍,“arr 本身就是一个指针”这种表述并不准确,严格来说应该是“arr 被转换成了一个指针”。这里请大家先忽略这个细节,我们将在 VIP教程《数组和指针绝不等价,数组是另外一种类型》和《数组到底在什么时候会转换为指针》中深入讨论。

    如果一个指针指向了数组,我们就称它为数组指针(Array Pointer)。

    数组指针指向的是数组中的一个具体元素,而不是整个数组,所以数组指针的类型和数组元素的类型有关,上面的例子中,p 指向的数组元素是 int 类型,所以 p 的类型必须也是int *

    反过来想,p 并不知道它指向的是一个数组,p 只知道它指向的是一个整数,究竟如何使用 p 取决于程序员的编码。

    更改上面的代码,使用数组指针来遍历数组元素:

     
    
    1. #include <stdio.h>
    2. int main(){
    3. int arr[] = { 99, 15, 100, 888, 252 };
    4. int i, *p = arr, len = sizeof(arr) / sizeof(int);
    5. for(i=0; i<len; i++){
    6. printf("%d ", *(p+i) );
    7. }
    8. printf("\n");
    9. return 0;
    10. }

    数组在内存中只是数组元素的简单排列,没有开始和结束标志,在求数组的长度时不能使用sizeof(p) / sizeof(int),因为 p 只是一个指向 int 类型的指针,编译器并不知道它指向的到底是一个整数还是一系列整数(数组),所以 sizeof(p) 求得的是 p 这个指针变量本身所占用的字节数,而不是整个数组占用的字节数。

    也就是说,根据数组指针不能逆推出整个数组元素的个数,以及数组从哪里开始、到哪里结束等信息。不像字符串,数组本身也没有特定的结束标志,如果不知道数组的长度,那么就无法遍历整个数组。

    上节我们讲到,对指针变量进行加法和减法运算时,是根据数据类型的长度来计算的。如果一个指针变量 p 指向了数组的开头,那么 p+i 就指向数组的第 i 个元素;如果 p 指向了数组的第 n 个元素,那么 p+i 就是指向第 n+i 个元素;而不管 p 指向了数组的第几个元素,p+1 总是指向下一个元素,p-1 也总是指向上一个元素。

    更改上面的代码,让 p 指向数组中的第二个元素:

     
    
    1. #include <stdio.h>
    2. int main(){
    3. int arr[] = { 99, 15, 100, 888, 252 };
    4. int *p = &arr[2]; //也可以写作 int *p = arr + 2;
    5. printf("%d, %d, %d, %d, %d\n", *(p-2), *(p-1), *p, *(p+1), *(p+2) );
    6. return 0;
    7. }

    运行结果:
    99, 15, 100, 888, 252

    引入数组指针后,我们就有两种方案来访问数组元素了,一种是使用下标,另外一种是使用指针。

    1) 使用下标

    也就是采用 arr[i] 的形式访问数组元素。如果 p 是指向数组 arr 的指针,那么也可以使用 p[i] 来访问数组元素,它等价于 arr[i]。

    2) 使用指针

    也就是使用 *(p+i) 的形式访问数组元素。另外数组名本身也是指针,也可以使用 *(arr+i) 来访问数组元素,它等价于 *(p+i)。

    不管是数组名还是数组指针,都可以使用上面的两种方式来访问数组元素。不同的是,数组名是常量,它的值不能改变,而数组指针是变量(除非特别指明它是常量),它的值可以任意改变。也就是说,数组名只能指向数组的开头,而数组指针可以先指向数组开头,再指向其他元素。

    更改上面的代码,借助自增运算符来遍历数组元素:

     
    
    1. #include <stdio.h>
    2. int main(){
    3. int arr[] = { 99, 15, 100, 888, 252 };
    4. int i, *p = arr, len = sizeof(arr) / sizeof(int);
    5. for(i=0; i<len; i++){
    6. printf("%d ", *p++ );
    7. }
    8. printf("\n");
    9. return 0;
    10. }

    运行结果:
    99  15  100  888  252

    第 8 行代码中,*p++ 应该理解为 *(p++),每次循环都会改变 p 的值(p++ 使得 p 自身的值增加),以使 p 指向下一个数组元素。该语句不能写为 *arr++,因为 arr 是常量,而 arr++ 会改变它的值,这显然是错误的。

    关于数组指针的谜题

    假设 p 是指向数组 arr 中第 n 个元素的指针,那么 *p++、*++p、(*p)++ 分别是什么意思呢?

    *p++ 等价于 *(p++),表示先取得第 n 个元素的值,再将 p 指向下一个元素,上面已经进行了详细讲解。

    *++p 等价于 *(++p),会先进行 ++p 运算,使得 p 的值增加,指向下一个元素,整体上相当于 *(p+1),所以会获得第 n+1 个数组元素的值。

    (*p)++ 就非常简单了,会先取得第 n 个元素的值,再对该元素的值加 1。假设 p 指向第 0  个元素,并且第 0 个元素的值为 99,执行完该语句后,第 0  个元素的值就会变为 100。

    展开全文
  • 数组指针和指针数组的区别
  • 数组指针和指针数组区别判断

    千次阅读 多人点赞 2022-03-24 18:33:59
    对于c语言的初学者来说,往往容易将数组指针和指针数组混淆,本文将对二者概念以及其用法进行详细解释。 1.&数组名 vs 数组名 &arr和arr有什么区别呢,&arr+1和arr+1又有什么区别呢,接下来请看下图。...

    目录

    前言

    1.&数组名 vs 数组名

    2.指针数组

    2.1指针数组的使用

    3.数组指针

    3.1数组指针的使用

    结语:


    前言

    对于c语言的初学者来说,往往容易将数组指针和指针数组混淆,本文将对二者概念以及其用法进行详细解释。

    1.&数组名 vs 数组名

    &arr和arr有什么区别呢,&arr+1和arr+1又有什么区别呢,接下来请看下图。

    由上图很容易看出,arr和&arr的值是一样的,但是所表示的意义是不一样的。

    实际上:&arr表示的是整个数组的地址,arr表示的是该数组首元素的地址。

    虽然二者的值相等,但是在arr+1与&arr+1上显示出的值是不一样的。arr+1与arr表示出的值相差4字节,即一个整型空间;&arr+1与&arr表示出的值相差40个字节,即10个整型空间;所以arr+1跳过的是该数组的一个整型元素,而&arr+1跳过的是整个数组的10个元素。

    补充:

    在数组名的使用中,有两种数组名的使用情况表示取出整个数组,其他情况都表示取出首元素的地址:

    1.sizeof(arr)表示的是计算整个数组的大小,sizeof内部单独放一个数组,数组名表示整个数组。

    2.&数组名,取出的是整个数组的地址,&数组名,数组名表示整个数组。

    2.指针数组

    指针数组即是存放指针的数组,本质上是数组,该数组存放的元素是指针。

    int arr[]是存放整型的数组;char arr[]是存放字符的数组;float arr[]是存放浮点型的数组;所以arr[]前的类型声明了该数组的类型,所以int*arr[]表示是存放整型指针的数组;char* arr[]是存放字符型指针的数组。

    2.1指针数组的使用

    如上图,该指针数组存放的是a b c整型变量的地址。

    3.数组指针

    数组指针本质是指针,如int*p表示的是指向整型数据的指针;float*p表示的是指向浮点型数据的指针,所以数组指针是指向数组的指针。

    数组指针的的书写:int (*p)[10],p和*先结合说明p是一个指针变量,然后指向的是一个大小为10的整型数组,所以叫数组指针。注意书写是()不可遗漏,[]的优先级大于(),必须保证*和p

    先结合。

    3.1数组指针的使用

    数组指针在二维数组中的使用例子如下。

    //打印二维数组
    #include <stdio.h>
    void print(int (*p)[5], int row, int col)
    {
    	int i = 0;
    	for (i = 0; i < row; i++)
    	{
    		int j = 0;
    		for (j = 0; j < col; j++)
    		{
    			printf("%d ", *(*(p + i) + j));
    				//p+i指向的是第i行的地址
    				// *(p+i)是取到了第i行的地址,
    				// *(p+i)+j是指向第i行第j列的地址
    				// *(*(p+i)+j)取出的是第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);
    	//数组名arr,表示首元素的地址。
    	//对于二维数组的首元素是第一行。
    	//所以传递的是第一行的地址,即一维数组的地址。
    	//可以用数组指针接受
    	return 0;
    }
    

    代码运行结果如上。

    结语:

    数组指针和指针数组的解释到此完结,初学者读了此篇应该有所收获。

     

     

    展开全文
  • 数组指针】 仅此一篇 让你深刻理解数组指针

    万次阅读 多人点赞 2020-04-27 00:12:34
    数组指针,顾名思义,就是指向数组的指针。 我们是这样定义它的:int(* p)[n] = { }; (n为要定义的个数) 按照优先级运算 ()与[ ] 优先级相同,根据结合律,就从左向右运算。 ()里是*p,先定义了指针,所以p是个...

    作者:Mitu_-_

    本帖内容著作权归作者所有,转载请务必保留本文链接

    数组指针

    数组指针,顾名思义,就是指向数组的指针。
    我们是这样定义它的:int(* p)[n] = { }; (n为要定义的个数)
    按照优先级运算运算符优先级
    ()与[ ] 优先级相同,根据结合律,就从左向右运算。
    ()里是*p,先定义了指针,所以p是个指针,然后后面是[ ],才是数组,即数组指针它指向了含有n个int类型的数组。
    数组指针
    如上图所示,假设定义 int (*p2)[5] = { 0, 0, 0, 0, 0}; 那么p2就指向了这个包含5个int类型的数组了。
    !!!注意:指向数组和指向数组首元素的地址是两码事。p2在内存中指向的是这个数组的首地址,是和数组有关联的,而绝不仅仅是指向数组首元素的地址。)

    就比如:
    int *p1 = b;
    int a[5] = {1, 2, 3, 4, 5};
    int *p2 = a;
    指针p1和p2就单纯的指向了变量,p1指向了变量b的地址,p2指向的是a数组首元素的地址,而不是指向这个数组,它与整个的数组是无关的。



    说了这么多,就用代码来演示吧!

    正面例证:

    #include <stdio.h>
    int main()
    {
    	int temp[5] = {1, 2, 3, 4, 5};
    	int (*p)[5] = &temp;
    	int i;
    	
    	for(i = 0; i < 5; i++)
    	{
    		printf("%d\n", *(*p + i));
    		//或者 printf("%d\n", (*p)[i]);
    	 } 
    	 return 0;
    }
    

    1)第一行定义了含有5个int类型的数组temp;
    2)第二行就定义了一个指向含有5个int类型数组的指针p,并把temp数组的首地址给了指针p。
    注意:这里为什么不直接用 int (*p)[5] = temp;呢?
    这是因为虽然temp和&temp的值都是相同的,但它们的意义却是不相同的:
    *** temp指的是这个数组的 第一个元素 的首地址。
    *** &temp 指的是这 整个数组 的首地址。

    这里如果直接用temp的话可能编译不通过,也可能编译通过,但会给出警告。这是我用dev c++编译时的警告:

    [Warning] initialization from incompatible pointer type
    

    可能你还会有点懵,接着往下看就会明白了:

    3)for循环是想把数组temp里面的数字都打出来。里面为什么用*(*p + i)呢?
    p所指的是数组temp的地址,
    *p+i 所指的是它在数组中的位置,
    *(*p + i)就表示相应位置上的值了。

    结果:

    在这里插入图片描述

    这里用VC反汇编一下你会理解的更加透彻:
    在这里插入图片描述
    1)由4: 5:8:可以看到它在[ ebp - 1 ] 到 [ ebp - 14]定义了1 —— 5 这5个数字,每个数字占四个字节。总共20个字节,也就是14h。
    在[ebp - 15] —— [ebp - 18]定义了数组指针。
    又在[ebp - 19] —— [ebp - 1C]定义了i。

    2)for里的i初始化完成后,就进入到printf里去了:请看10:
    第一行:把 i 的值放入edx里。
    第二行:把指针p的值也就是数组temp的首地址放入eax中。
    第三行:注意:[eax+edx*4],也就是把数组temp的地址 + i * 4 送入ecx里,这就是前面所说的“ *p+i 所指的是它在数组中的位置 ”的意思了。


    反面例证:

    #include <stdio.h>
    int main()
    {
    	int temp[5] = {1, 2, 3, 4, 5};
    	int (*p)[5] = &temp;
    	int i;
    	
    	for(i = 0; i < 5; i++)
    	{
    		printf("%d\n", *(p + i));
    	 } 
    	 return 0;
    }
    

    有些不太理解的小伙伴可能会这样写:printf("%d\n", *(p + i));
    “p+i 就是它在数组中的位置,外面再加个取值运算符 * 就行了嘛”,其实不然,这是它的结果:
    在这里插入图片描述
    为什么会是这样呢???
    如果上面的都看懂了,这也就不难理解了。别忘了前面所说的指向数组和指向数组首元素的地址是两码事。
    这里的指针p指向的是数组temp,那么p + 1就是p + 整个temp数组的长度咯。请看上面结果的前三行
    6487536 (十进制) ——→ 62FDF0(十六进制)
    6487556 (十进制) ——→ 62FE04(十六进制)
    6487576 (十进制) ——→ 62FE18(十六进制)

    可以看出每个数据之间都差 14H,也就是数组的长度4*5=20(D)=14(H)

    这是它的反汇编:
    在这里插入图片描述
    上面和前面的基本差不多,直接看10:
    第一行:i 的值放入edx里。
    第二行:注意:imul edx, edx, 14h ,imul指令是将后面两个数相乘放入第一个寄存器中,也就是把edx*14的值放入edx中。
    所以反面例证里循环一次变化的地址距长度是14h,也就是20个字节; 而上面正面例证的的循环一次变化的地址长度是4h,就是4个字节。



    展开全文
  • ·详解数组指针与指针数组 ·数组指针 ⾸先我们需要了解什么是数组指针以及什么是指针数组,如下图: int *p[5]; int (*p)[5]; 数组指针的意思即为通过指针引⽤数组,p先和*结合,说明了p是⼀个指针变量,指向⼀个...
  • 指针数组与数组指针详解

    万次阅读 多人点赞 2016-09-28 21:21:20
    指针数组与数组指针详解1.什么是指针数组和数组指针? 指针数组:指针数组可以说成是”指针的数组”,首先这个变量是一个数组,其次,”指针”修饰这个数组,意思是说这个数组的所有元素都是指针类型,在32位系统中...
  • 数组指针的使用方法

    千次阅读 2022-05-04 11:23:31
    数组指针与指针数组、数组指针的用法、字符串排序输出(代码实例)
  • C/C++中数组指针与指针数组

    千次阅读 2022-04-21 14:40:05
    1.数组指针的定义方式有三种: #include<iostream> using namespace std; //第一种方法:通过数据类型定义数组指针 void test01() { int arr[3] = {1,2,3} tpyedef int(ARRAY_TYPE)[3];//ARRAY_TYPE是...
  • c语言之——指针数组与数组指针

    千次阅读 2021-04-07 10:53:19
    2. 数组指针:是指一个指向数组的指针,它其实还是一个指针,只不过是指向数组而已; 定义形式:int (*p)[10]; 其中,由于[]的优先级高于*,所以必须添加(*p). 区分方法: 主要看后面的两个字是什么(前面是修饰...
  • 数组指针(指向数组的指针)

    千次阅读 2022-01-22 01:16:07
    数组指针顾名思义是指向数组的指针,数组指针存放的是数组的地址 这里的int(*p)[10] 括号*p的意思是让p先和*号配对确保是个指针,然后去掉*p可以知道指针p变量指向的是一个数组,有10个元素,每个元素是int类型 ...
  • C语言中数组指针和指针数组的区别
  • 本文较为详细的分析了关于理解C++指针数组,数组指针,数组名,二维数组的一些技巧。是比较重要的概念,相信对于大家的C++程序设计有一定的帮助作用。 一、关于数组名 假设有数组: int a[3] = {1, 2, 3} 1.数组...
  • 二维数组与数组指针详解

    千次阅读 多人点赞 2020-07-26 18:18:53
    新的理解:我们可以这样认为,a可以看作是一个一维数组,包含2个元素,每个元素恰好是包含3个整型的元素,a这个名字的值成了指向一个包含3个整型元素的数组的指针(你学过数组指针就该知道,他们是一个道理,后面我...
  • 数组:一组数据的集合...当然数组中除了存储一般常见的数据类型外,也可以用来存放指针,此时的数组就叫指针数组指针数组指针数组的元素全为指针。它的声明方法是:数据类型 * 数组名[数组长度];例如int arr[5];
  • C语言之数组指针、指针数组

    千次阅读 2021-10-20 22:57:41
    文章目录数组和指针问题导引作为函数参数的数组名数组指针:指向数组的指针指针数组:数组元素为指针栈区指针数组 数组和指针 问题导引 指针和数组并不是相等的。为了说明这个概念,请考虑下面两个声明: int a[10];...
  • C语言 数组 指针 C语言深度解析!彻底了解指针数组,数组指针以及函数指针,很不错的文档,不敢独享,大家一起学习
  • 一、C语言中的数组指针与指针数组 首先我们需要了解什么是数组指针以及什么是指针数组,如下图: int *p[5]; //指针数组 int (*p)[5]; //数组指针 那么两个之间有什么区别呢: 数组指针的意思即为通过指针引用数组...
  • 在概念上是二维的,有行和列,但在内存中所有的数组元素都是连续排列的,它们之间没有 “缝隙”。以下面的二维数组 a 为例: int a[3][4] = { {0, 1, 2, 3}, {4, 5, 6, 7}, {8, 9, 10, 11} }; 从概念上理解,a ...
  • 用于比较指针数组和数组指针实现算法的差异,利用函数返回指针实现。 可作为研究C语言指针使用的范例程序。 有源代码和实现结果图。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,033,998
精华内容 413,599
关键字:

数组指针