精华内容
下载资源
问答
  • 文章目录一维数组指针和二维数组指针的定义一维数组指针和二维数组指针用于索引数组元素一维数组指针和二维数组指针的可视化解读 一维数组指针和二维数组指针的定义 一维数组指针的定义就是普通指针的定义 指针变量...

    一维数组指针和二维数组指针的定义

    • 一维数组指针的定义就是普通指针的定义 指针变量类型 *指针变量名称 --> int *p
    • 二维数组指针变量的定义略微复杂:指针变量类型 *指针变量名称[二维数组的列数] --> int(*p2)[3]

    一维数组指针和二维数组指针用于索引数组元素

    在这里插入图片描述

    一维数组指针和二维数组指针的可视化解读

    在这里插入图片描述

    使用二维数组指针的实例演示

    • 题目:使用二维数组指针,通过输入行数和列数,打印出二维数组对应的索引的值。
      在这里插入图片描述【代码】
    #define _CRT_SECURE_NO_WARNINGS
    #include<stdio.h>
    void main() {
    	int a, b;
    	printf("c数组是一个2行3列的数组\n");
    	printf("请输入您想要索引的行和列\n");
    	scanf("%d %d",&a,&b);
    
    	int c[][3] = { {1,2,3},
    				   {4,5,6} };
    	int(*p)[3] = c;
    
    	printf("c[%d][%d]=%d\n", a, b, *(*(p + a) + b));  //使用指针的索引方式
    
    	printf("c[%d][%d]=%d\n", a, b, c[a][b]);	// 使用数组直接索引
    }
    
    展开全文
  • 维数组与指针、指针数组、数组指针用法

    万次阅读 多人点赞 2018-03-12 18:16:20
    二维数组和指针⑴ 用指针表示二维数组元素。要用指针处理二维数组,首先要...而每个大数组元素对应二维数组的一行,我们就称之为行数组元素,显然每个行数组元素都是一个一维数组下面我们讨论指针和二维数组元素的...

    二维数组和指针⑴ 用指针表示二维数组元素。
    要用指针处理二维数组,首先要解决从存储的角度对二维数组的认识问题。我们知道,一个二维数组在计算机中存储时,是按照先行后列的顺序依次存储的,当把每一行看作一个整体,即视为一个大的数组元素时,这个存储的二维数组也就变成了一个一维数组了。而每个大数组元素对应二维数组的一行,我们就称之为行数组元素,显然每个行数组元素都是一个一维数组

    下面我们讨论指针和二维数组元素的对应关系,清楚了二者之间的关系,就能用指针处理二维数组了。
    设p是指向二维数组a[m][n]的指针变量,则有:

    int* p=a[0];//此时P是指向一维数组的指针。P++后,p指向 a[0][1]。

    如果定义int (*p1)[n];p1=a;p1++后,p1指向a[1][0];  

    则p+j将指向a[0]数组中的元素a[0][j]。
    由于a[0]、a[1]┅a[M-1]等各个行数组依次连续存储,则对于a数组中的任一元素a[i][j],指针的一般形式如下:
    p+i*N+j             相应的如果用p1来表示,则为*(p1+i)+j
    元素a[i][j]相应的指针表示为:
    *( p+i*N+j)         相应的如果用p1来表示,则为*(*(p1+i)+j)
    同样,a[i][j]也可使用指针下标法表示,如下:
    p[i*N+j]
    例如,有如下定义:
    int a[3][4]={{10,20,30,40,},{50,60,70,80},{90,91,92,93}};
    则数组a有3个元素,分别为a[0]、a[1]、a[2]。而每个元素都是一个一维数组,各包含4个元素,如a[1]的4个元素是a[1][0]、a[1][1]、a[1]2]、a[1][3]。
    若有:
    int *p=a[0];
    则数组a的元素a[1][2]对应的指针为:p+1*4+2
    元素a[1][2]也就可以表示为:*( p+1*4+2)
    用下标表示法,a[1][2]表示为:p[1*4+2]
    特别说明:
    对上述 二维数组a,虽然a[0]、a都是数组首地址,但二者指向的对象不同,a[0]是一维数组的名字,它指向的是a[0]数组的首元素,对其进行“*”运算,得到的是一个数组元素值,即a[0]数组首元素值,因此,*a[0]与a[0][0]是同一个值;而a是一个 二维数组的名字,它指向的是它所属元素的首元素,它的每一个元素都是一个行数组,因此,它的指针移动单位是“行”,所以a+i指向的是第i个行数组,即指向a[i]。对a进行“*”运算,得到的是一维数组a[0]的首地址,即*a与a[0]是同一个值。 当用int *p;定义指针p时,p的指向是一个int型数据,而不是一个地址,因此,用a[0]对p赋值是正确的,而用a对p赋值是错误的。这一点请读者务必注意。
    ⑵ 用 二维数组名作地址表示数组元素。
    另外,由上述说明,我们还可以得到 二维数组元素的一种表示方法:
    对于 二维数组a,其a[0]数组由a指向,a[1]数组则由a+1指向,a[2]数组由a+2指向,以此类推。因此,*a与a[0]等价、*(a+1)与a[1]等价、*(a+2)与a[2]等价,┅,即对于a[i]数组,由*(a+i)指向。由此,对于数组元素a[i][j],用数组名a的表示形式为:
    *(*(a+i)+j)
    指向该元素的指针为:
    *(a+i)+j

    数组名虽然是数组的地址,但它和指向数组的指针变量不完全相同。

    第一,指针变量的值可以改变,即它可以随时指向不同的数组或同类型变量,而数组名自它定义时起就确定下来,不能通过赋值的方式使该数组名指向另外一个数组。

    第二,数组名是指针,类型是指向元素类型的指针,但值是指针常量,声明数组时编译器会为声明所指定的元素数量保留内存空间。数组指针是指向数组的指针,声明指针变量时编译器只为指针本身保留内存空间。

    例4 求 二维数组元素的最大值。


    该问题只需对数组元素遍历,即可求解。因此,可以通过顺序移动数组指针的方法实现。
    main()
    {
    int a[3][4]={{3,17,8,11},{66,7,8,19},{12,88,7,16}};
    int *p,max;
    for(p=a[0],max=*p;p<a[0]+12;p++)
       if(*p>max)
          max=*p;
    printf("MAX=%d/n",max);
    }
    执行结果:
    MAX=88
    这个程序的主要算法都是在for语句中实现的:p是一个int型指针变量;p=a[0]是置数组的首元素地址为指针初值;max=*p将数组的首元素值a[0][0]作为最大值初值;p<a[0]+12是将指针的变化范围限制在12个元素的位置内;p++使得每比较一个元素后,指针后移一个元素位置。
    例5 求二维数组元素的最大值,并确定最大值元素所在的行和列。
    本例较之上例有更进一步的要求,需要在比较的过程中,把较大值元素的位置记录下来,显然仅用上述指针移动方法是不行的,需要使用能提供行列数据的指针表示方法。
    main()
    {
    int a[3][4]={{3,17,8,11},{66,7,8,19},{12,88,7,16}};
    int *p=a[0],max,i,j,row,col;
    max=a[0][0];
    row=col=0;
    for(i=0;i<3;i++)
       for(j=0;j<4;j++)
         if(*(p+i*4+j)>max)
          {
            max=*(p+i*4+j);
            row=i;
            col=j;
          }
    printf("a[%d][%d]=%d/n",row,col,max);
    }
    程序运行结果:
    a[2][1]=88
    ⑶ 行数组指针
    在上面的说明中我们已经知道,二维数组名是指向行的,它不能对如下说明的指针变量p直接赋值:
    int a[3][4]={{10,11,12,13},{20,21,22,23},{30,31,32,33}},*p;
    其原因就是p与a的对象性质不同,或者说二者不是同一级指针。C语言可以通过定义行数组指针的方法,使得一个指针变量与二维数组名具有相同的性质。行数组指针的定义方法如下:
    数据类型 (*指针变量名)[二维数组列数];
    例如,对上述a数组,行数组指针定义如下:
    int (*p)[4];
    它表示,数组*p有4个int型元素,分别为(*p)[0]、(*p)[1]、(*p)[2]、(*p)[3] ,亦即p指向的是有4个int型元素的一维数组,即p为行指针

    此时,可用如下方式对指针p赋值:

    p=a;

    (4)指针数组的定义

    指针数组是指每个元素中存放的是指针。定义为 int *p[4];sizeof(p)=16,返回的是数组的总空间

    展开全文
  • int main ( ) { char a[2][3]={ {1,2,3} , {4,5,6} } ; char (*p) [3]; p=a; printf (“%d , %d , %d , %d ,%d ”, a , &a, *a, **a, *(*(p+1) + 2));  return 0; } ...貌似很简单的个题
     int   main (  )
    {
       char  a[2][3]={ {1,2,3} , {4,5,6} } ; 
       char   (*p) [3]; 
        p=a;
       printf (“%d , %d , %d , %d ,%d ”, a , &a, *a, **a,  *(*(p+1) + 2)); 
       return   0;
    }
       请问输出该是多少?貌似很简单的一个题目,却不觉得让人看得有点头大。如果您已能很清晰地理解本题的话,那就无需再浪费您的时间了,请继续飘过吧…如果觉得有点疑惑的话,且听我细细道来。如果哪里说错了还请指正。
       先讨论下这个问题:char *pC; 假设此时pC里面的值是0x00012,如果pC++,那么pC会是多少呢?很显然是0x00013对吧。如果是int *pInt;也假设pInt 的值是0x00012,那么pInt++后的值就应该是0x00016了吧......关于这个问题你可以简单的理解为是由于地址对齐的缘故!说了这么多,我只想说,如果想看看某个指针指向的空间占多少字节,可以用这个方法。接下来用这个方法解释下面这些问题。
    
       且看第一句,这句很显然没问题,是人都知道这不过是定义了一个二维数组,两行三列,并且分别给它们赋值而已。大家一看就知道,a就是这个数组的首地址,这个每本书每个老师都是这样说的,虽然不知道为什么……
    
       第二句嘛,咋一看有点像个数组,可是括号里面却有个*p。好像比较少见。不急,大家可以联想到:char  * p [3] ; 有眼睛的一看就可以看得出来,这只不过把括号给去掉了。好吧,我就看上面没有括号的那句,很显然,这句绝大多数人看一眼就知道这其实就是个指针数组,也就是:(char *)  p[3] ; 跟普通的数组没啥区别,只不过这个数组里面每个成员都是个char *类型的字符指针。对没错,可是加了个括号呢?char  (*p)  [3]又表示什么呢?好,如果你开始觉得有点模糊了,那么你很正常,因为我刚开始也是这样的。再看看下面这两句:typedef  char   p_Char[3];    p_Char  *p; 这句中的p表示什么呢?也许你还不是很清晰,但你应该可以确定是个某种类型的指针。如果你对这里的typedef的用法不太了解的话,那么也许你应该去百度一下关于typedef的用法,这里就不说了,我只告诉你此处的p跟上面的char  (*p)[3] 是完全一样的效果。也就是说此处并不是定义数组,而只是个指针,而这个指针指向的变量不是普通的char,而是一个有三个元素的数组。你可以试试看sizeof(p)的值是多少,结果应该是4吧,会是个数组吗?你还可以输出一下p和p++的值,看看它们相差多少?应该是3吧!
    
       这第三句就更简单了,一个简单的赋值语句,把二级指针a(也就是二维数组的首地址)赋值给p(也是个二级指针)。
    
       第四句就是个输出语句,我们直接看后面的参数,a的值应该是数组的首地址吧,&a好像没这种用法,你有见过吗?如果你怀疑编译器会报错的话,你大可一试,至少我在VC6.0上面可以通过。a本身就是个地址,再取地址会是什么呢?也许你是这样想,不奇怪,我也这样想。再看看*a这个也可以理解,a是个地址嘛,*a也就是a这个地址里面的值咯。好像说的也没错。
    
       好吧,上面对那个小程序的一点分析只不过是个引子,接下来才是我真正要说的。我们来想想学了C语言后,一共有多少种数据类型呢?从int、short、long、double、char、char*、到char a[3],到int aa[5],再到struct a{ int a, char c; } aa ;我们可以看到可以共可分为三种,第一是最基本的类型,比如:int、short、char等......第二是在最基本的类型上扩充而来的,也就是数组,由多个相同类型组成的,第三种则是由不同的类型组成的,也就是结构体。
    
       我们再来看看如下情况:int  a;  char b[5];  struct a  aa; 至于这是什么,也许你应该去看看谭浩强的C语言。那a、b、aa、的值分别是什么呢?当然这里并不关心它的真正值,只是想说明它们分别表示什么!很显然,a的值就是编译器在堆栈里面分配的4个字节空间里面的内容,aa也类似,但是b呢?b本应该也表示这5个字节里面所表示的内容,也就是说b本应该代表从b[0]到b[4]这几个空间里面的内容,但是需要注意的是因为它是数组,所以实际上编译器给出了单独的例外处理:当某处引用数组名字的时候并不代表数组里面的所有内容,而是代表了该数组的首地址。这说明:当我们用数组名字的时候要注意,一般情况,把它理解为地址,如果是形如“&  数组名”则还可把数组名看做数组整体内容。我们可以跟上面的a和aa对比一下,对于普通的a很显然,当引用a的时候我们就理所当然的以为是该空间里面所包含的内容,当我们引用结构体变量名的时候我们也理所当然的把他当做该结构体所占空间里面的内容,对于数组,按照我们刚才的那种思维逻辑,数组名其实也是代表这个数组里面真正包含的内容,而不是其首地址。是的我们本应该这样理解。但实际情况则不同,编译器不会这样做。这就是为什么我们老师苦口婆心不厌其烦地告诉我们数组名就是首地址的缘故了。所以回到刚开始那个问题,用我们上面的话说,&a中的a可以表示的是整个数组内容,所以取其地址还是数组地址,当然此时的a也可以理解成地址,但由于a是个二维数组,也就是个二级指针,那么&a就应该是个三级指针了。所以如果要把&a赋值给某个指针变量的话,那它应该是形如char  (*p)[2][3]类型的变量了;  *a表示的是什么呢?这个问题也很让人纠结......是表示数组的第一个元素的值吗?你可以试试,本题结果还是地址。为什么呢?接下来才是本文要说明的核心。
    
       相信大家都知道,一个一维数组的数组名是个一级指针,而二维数组的名就是个二级指针,三维数组的名字就是三级指针......以此类推。我是不知道您是怎么理解二级指针和三级指针的,在我看来,所谓二级指针其实也是个指针,只不过它指向的空间必须是个一级指针,而该一级指针指向的空间就是真正要指向的那个变量地址。也就是说一维数组名是个一级指针,那么对于char  C[2]={1,2}; 因为C是个一级指针,所以&C就应该是二级指针了。C可以赋值给char *p类型的变量,而&C却只能赋值给char  (*p)[2];类型的指针,注意此处的p也是个二级指针。这时你可以用上面的方法试试C+1和C的值相差多少个字节?应该是大2吧!*C的值就应该是数组的第一个元素的值了。对于二维数组char C[2][3]= { {1,2,3 },{4,5,6 } };C是个二级指针,你也可以试看看C+1和C究竟差了多少个字节?应该是6吧!既然C是个二级指针也就是说*C是个一级指针,虽然指向的地址和C指向的地址是同一个,但是此时表达的意义就大不一样了。C是个二级指针,而且它指向的范围是从1~6,而*C是个一级指针,范围从1~3,你可以试试(*C+1)和*C相差多少?应该是3吧!。那**C呢?很显然一级指针指向的空间就不会是地址了,而应该是地址里面的内容了,也就是1。对于三维、四维等情况都是类似的,以此类推.....
    
       最后我们来看看 *( *(p+1) +2 )的值会是多少?首先p是个指针,里面存放的地址是一个char[3]类型的地址,而p又被赋值了a,所以p+1就应该指向下一个char[3]类型的地址,也就是指向了a数组的第二行首地址,*(p+1)很显然就是指数组a的第二行里面的内容,根据刚才的分析,如果是数组的话,一个表示数组整体内容的其实就是用其首地址来表示,所以*(p+1)表示的是数组a的第二行的首地址,然后*(p+1) +2 表示的就是第二行的第二个地址,最后*(*(p+1) + 2)表示的就是第二行的第二个地址所存放的内容,也就是6。
    
       貌似我把一个很简单的问题说了很多,接下来我要问问几个问题看看你究竟理解了我说的没有,请看下题:
    对一维数组:char  C[3];,请问如何定义一个指针变量P0,使得这句:P0=C;能通过编译?如何定义一个指针变量P1,使得P1=&C能通过?*C表示什么?
    对二维数组:Char  C[2][3];如何定义一个指针变量P0使得P0=C;能通过编译?如何定义指针变量P1使得可以P1=&C; *C表示什么?**C又表示什么?这些有啥区别和联系?
    后面的我就不多说了,如果你能很清晰的理解这些东西,那么你就懂了,否则那就请把本文再从头看一遍吧!
    
    展开全文
  • 维数组指针表示,C语言指针引用二维数组详解

    千次阅读 多人点赞 2019-12-09 14:43:53
    但是在概念和使用方法上,二维数组的指针一维数组指针要复杂一些。要理解指针和二维数组的关系首先要记住一句话:二维数组就是一维数组,这句话该怎么理解呢? 假如有一个二维数组: int a[3][4] = {{1, 3, ...

    指针变量可以指向一维数组中的元素,当然也就可以指向二维数组中的元素。但是在概念和使用方法上,二维数组的指针比一维数组的指针要复杂一些。要理解指针和二维数组的关系首先要记住一句话:二维数组就是一维数组,这句话该怎么理解呢?

    假如有一个二维数组:

    int a[3][4] = {{1, 3, 5, 7}, {9, 11, 13, 15}, {17, 19, 21, 23}};

    其中,a 是二维数组名。a 数组包含 3 行,即 3 个行元素:a[0],a[1],a[2]。每个行元素都可以看成含有 4 个元素的一维数组。而且 C 语言规定,a[0]、a[1]、a[2]分别是这三个一维数组的数组名。如下所示:

    在这里插入图片描述

    a[0]、a[1]、a[2] 既然是一维数组名,一维数组的数组名表示的就是数组第一个元素的地址,所以 a[0] 表示的就是元素 a[0][0] 的地址,即 a[0] == &a[0][0];a[1] 表示的就是元素 a[1][0] 的地址,即 a[1] == &a[1][0];a[2] 表示的就是元素 a[2][0] 的地址,即 a[2] == &a[2][0]。

    所以二维数组a[M][N]中,a[i]表示的就是元素a[i][0]的地址,即(式一):

    a[i] == &a[i][0]

    我们知道,在一维数组 b 中,数组名 b 代表数组的首地址,即数组第一个元素的地址,b+1 代表数组第二个元素的地址,…,b+n 代表数组第 n+1 个元素的地址。所以既然 a[0]、a[1]、a[2]、…、a[M–1] 分别表示二维数组 a[M][N] 第 0 行、第 1 行、第 2 行、…、第 M–1 行各一维数组的首地址,那么同样的道理,a[0]+1 就表示元素 a[0][1] 的地址,a[0]+2 就表示元素 a[0][2] 的地址,a[1]+1 就表示元素 a[1][1] 的地址,a[1]+2 就表示元素 a[1][2] 的地址……a[i]+j 就表示 a[i][j] 的地址,即(式二):

    a[i]+j == &a[i][j]

    将式一代入式二得(式三):

    &a[i][0]+j == &a[i][j]

    在一维数组中 a[i] 和 *(a+i) 等价,即(式四):

    a[i] == *(a+i)(13-4)

    这个关系在二维数组中同样适用,二维数组 a[M][N] 就是有 M 个元素 a[0]、a[1]、…、a[M–1] 的一维数组。将式四代入式二得(式五):

    *(a+i)+j == &a[i][j]

    由式二和式五可知,a[i]+j 和 *(a+i)+j 等价,都表示元素 a[i][j] 的地址。

    上面几个公式很“绕”,理清楚了也很简单,关键是把式二和式五记住。


    二维数组的首地址和数组名

    下面来探讨一个问题:“二维数组 a[M][N] 的数组名 a 表示的是谁的地址?”在一维数组中,数组名表示的是数组第一个元素的地址,那么二维数组呢? a 表示的是元素 a[0][0] 的地址吗?不是!我们说过,二维数组就是一维数组,二维数组 a[3][4] 就是有三个元素 a[0]、a[1]、a[2] 的一维数组,所以数组 a 的第一个元素不是 a[0][0],而是 a[0],所以数组名 a 表示的不是元素 a[0][0] 的地址,而是 a[0] 的地址,即:

    a == &a[0]

    而 a[0] 又是 a[0][0] 的地址,即:

    a[0] == &a[0][0]

    所以二维数组名 a 和元素 a[0][0] 的关系是:

    a == &(&a[0][0])

    即二维数组名 a 是地址的地址,必须两次取值才可以取出数组中存储的数据。对于二维数组 a[M][N],数组名 a 的类型为 int(*)[N],所以如果定义了一个指针变量 p:

    int *p;

    并希望这个指针变量指向二维数组 a,那么不能把 a 赋给 p,因为它们的类型不一样。要么把 &a[0][0] 赋给 p,要么把 a[0] 赋给 p,要么把 *a 赋给 p。前两个好理解,可为什么可以把 *a 赋给 p?因为 a==&(&a[0][0]),所以 a==(&(&a[0][0]))==&a[0][0]。

    除此之外你也可以把指针变量 p 定义成 int(*)[N] 型,这时就可以把 a 赋给 p,而且用这种方法的人还比较多,但我不喜欢,因为我觉得这样定义看起来很别扭。

    如果将二维数组名 a 赋给指针变量 p,则有(式六):

    p == a

    那么此时如何用 p 指向元素 a[i][j]?答案是以“行”为单位进行访问。数组名 a 代表第一个元素 a[0] 的地址,则 a+1 就代表元素 a[1] 的地址,即a+1==&a[1];a+2 就代表 a[2] 的地址,即 a+2==&a[2]……a+i 就代表 a[i] 的地址,即(式七):

    a+i == &a[i]

    将式六代入式七得:

    p+i == &a[i]

    等式两边作“*”运算得:

    *(p+i) == a[i]

    等式两边同时加上j行(式八):

    *(p+i) + j == &a[i][j]

    式八就是把二维数组名 a 赋给指针变量 p 时,p 访问二维数组元素的公式。使用时,必须先把 p 定义成 int()[N] 型,然后才能把二维数组名 a 赋给 p。那么怎么把 p 定义成 int()[N] 型呢?关键是 p 放什么位置!形式如下:

    > int (*p)[N] = a;    /*其中N是二维数组a[M][N]的列数, 是一个数字, 前面说过, 数组长度不能定义成变量*/
    

    下面编一个程序来用一下:

    # include <stdio.h>
    int main(void)
    {
        int a[3][4] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
        int i, j;
        int (*p)[4] = a;  //记住这种定义格式
        for (i=0; i<3; ++i)
        {
            for (j=0; j<4; ++j)
            {
                printf("%-2d\x20", *(*(p+i)+j));  /*%-2d中, '-'表示左对齐, 如果不写'-'则默认表示右对齐;2表示这个元素输出时占两个空格的空间*/
            }
            printf("\n");
        }
        return 0;
    }
    

    输出结果是:

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

    如果把 &a[0][0] 赋给指针变量 p 的话,那么如何用 p 指向元素 a[i][j] 呢?在前面讲过,对于内存而言,并不存在多维数组,因为内存是一维的,内存里面不分行也不分列,元素都是按顺序一个一个往后排的,所以二维数组中的每一个元素在内存中的地址都是连续的,写一个程序来验证一下:

    # include <stdio.h>
    int main(void)
    {
        int a[3][4] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
        int i, j;
        for (i=0; i<3; ++i)
        {
            for (j=0; j<4; ++j)
            {
                printf("%#X\x20", &a[i][j]);
            }
            printf("\n");
        }
        return 0;
    }
    

    输出结果是:

    0X18FF18 0X18FF1C 0X18FF20 0X18FF24
    0X18FF28 0X18FF2C 0X18FF30 0X18FF34
    0X18FF38 0X18FF3C 0X18FF40 0X18FF44
    

    我们看到地址都是连续的。所以对于数组 a[3][4],如果把 &a[0][0] 赋给指针变量 p 的话,那么:

    p == &a[0][0]; p + 1 == &a[0][1]; p + 2 == &a[0][2]; p + 3 ==
    &a[0][3]; p + 4 == &a[1][0]; p + 5 == &a[1][1]; p + 6 == &a[1][2];
    p + 7 == &a[1][3]; p + 8 == &a[2][0]; p + 9 == &a[2][1]; p + 10
    == &a[2][2]; p + 10 == &a[2][3];

    如果仔细观察就会发现有如下规律:

    p+i*4+j == &a[i][j]

    其中 4 是二维数组的列数。

    所以对于二维数组 a[M][N],如果将 &a[0][0] 赋给指针变量 p 的话,那么 p 访问二维数组元素 a[i][j] 的公式就是:

    p + i*N +j == &a[i][j]

    下面把验证式八的程序修改一下,验证一下上式:

    # include <stdio.h>
    int main(void)
    {
        int a[3][4] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
        int i, j;
        int *p = &a[0][0];  //把a[0][0]的地址赋给指针变量p
        for (i=0; i<3; ++i)
        {
            for (j=0; j<4; ++j)
            {
                printf("%-2d\x20", *(p+i*4+j));
            }
            printf("\n");
        }
        return 0;
    }
    

    输出结果是:

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

    结果是一样的。两种方法相比,第二种方法更容易接受,因为把 &a[0][0] 赋给指针变量 p 理解起来更容易,而且 p 定义成 int* 型从心理上或从感觉上都更容易接受。

    展开全文
  • 1.一维数组的地址 在C语言中,数组名是个不占内存的地址常量,它代表整个数组的存储首地址。 一维数组元素a[i]的地址可以写成表达式&a[i]或a+i,&a[i]是用下标形式表示的地址,a+i是用指针形式表示的地址,...
  • C语言语法笔记 – 高级用法 指针数组 指针的指针 二维数组... C语言语法笔记 – 高级用法 指针数组 指针的指针 二维数组指针 结构体指针 链表 | IT宅.comC语言语法笔记 – 高级用法 指针数组 指针的指针 二维数组...
  • C语言二维数组指针(指向二维数组的指针)详解

    千次阅读 多人点赞 2020-05-27 17:43:22
    如有需要,请访问C语言二维数组指针(指向二维数组的指针)详解 二维数组在概念上是二维的,有行和列,但在内存中所有的数组元素都是连续排列的,它们之间没有“缝隙”。以下面的二维数组 a 为例: int a[3][4] = { ...
  • 概念详解:指针指针与“int a”,...一维数组:定义一维数组之后,即在内存中分配一段连续的地址空间,如C语言中,int num[5],在32位系统中,int占据4个字节,现假设num[0]的地址空间为0x00000004,那么num[...
  • C++二维数组指针用法

    2019-08-15 17:36:16
    //*p是指针,指向数组a的第个元素的位置。*(*p)取的是数组数组a的第个元素a cout *(*(p + 1)):" *(*(p + 1)) ; //在p上移动是按行移动,*(p + 1)是指向数组a的第二行第列的位置,*(*(p + 1))取值为c p++;//p...
  • 指向具有M个元素的一维数组指针 注意:指向的是一维数组,而不是之前提到的指向一维数组的某个元素!!! 定义格式: 类型名 (*变量名)[M] ; 注意:M是一维数组的元素个数,类型名是一维数组的元素类型。 ...
  • (*p)[n]:根据优先级,先看括号内,则p是一个指针,这个指针指向一个一维数组,数组长度为n,这是“数组的指针”,即数组指针; *p[n]:根据优先级,先看[],则p是一个数组,再结合*,这个数组的元素是指针类型,共...
  • 1:数组指针本质上是一个指针,而且是一个指向数组的指针(又称为行指针),在这声明一下数组指针是指向二维数组的,对于一维数组数组没有任何意义。指针数组本质是一个数组,它的目的把相同类型的指针统一放在一个...
  • 文章目录一、一维数组名称含义二、数组指针三、二维数组名称含义四、选择排序五、指针数组排序 一、一维数组名称含义 一维数组名称含义: 1.除了两种特殊情况,一维数组名称都是指向数组首元素地址的指针。 特殊情况...
  • 维数组指针

    2020-01-24 20:19:20
    目录●´∀`●二维数组指针——行指针和列指针写在前面——“int[N]型”数据类型二维数组指针行指针列指针 二维数组指针——行指针和列指针 写在前面——“int[N]型”数据类型 “int[N]型”数据类型:C语言中并不...
  • 关于用指针方式访问二维数组的问题 首先说明几种类型: ... //该语句是定义一个指向数组的指针,指向含4个int元素的一维数组。跨度为4*sizeof(int); int * q2[4]; //定义了一个数组 里面存有int *...
  • LOGO 数组与指针一维数组地址和指针 主讲人周芸 教学目标 掌握一维数组的指针的用法 理解一维数组指针的本质 具备应用一维数组指针编程的能力 张丽去排队打疫苗医生通过叫号的方式依次注射 引入 一指向一维数组的...
  • 例程: /**********************************...* 文件描述:例看二维数组,指针,二维数组指针 * * 创建人:Jesse * * 版本号: * * 修改记录: * ******************************************************/ #include
  • 一维数组使用一维数组在内存中的存储。 一维数组指针访问。 二维数组的创建和初始化。 二维数组的使用。 二维数组在内存中的存储。 二维数组的指针访问。 一维数组的创建和初始化 数组的创建 对数组...
  • 二维数组:二维数组可以看作是一个一维数组,在本质上是以数组为数组元素的数组。从内存空间上看,int a[2][5]和int a[10]同样占用连续的10个int型空间。 数组指针:一般短语前面做修饰,后面为名词。数组指针,...
  • 本文转载于 ...在数组中,如果它的元素全部都是指针类型的数据,
  • 数组 | 指针数组 | 数组指针一维数组含义用法指针数组含义用法二维数组 | 数组指针含义用法 一维数组 含义 这个比较基础,顾名思义即可。 定义 int p[5]; 数组包含5个元素,每一个元素都是int型的数据。 用法 ...
  • Python numpy实现二维数组和一维数组拼接的方法撰写时间:2017.5.23一维数组1.numpy初始化一维数组a = np.array([1,2,3]);print a.shape输出的值应该为(3,)二维数组2.numpy初始化二维数组a = np.array([[1,2,3]])...
  • 维数组指针传递

    千次阅读 2018-03-25 19:02:37
    向C函数中传递指向二维数组的指针参数 先来回顾一下一维数组,一维数组的数组名即为指向该数组的指针,该指针值保存了数组存放在内存中的一块连续区域的起始地址;数组的下标表示了这片内存区域的某存储区相对于...
  • 1.指向一维数组指针,可以改变指针的指向,fangw

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 70,489
精华内容 28,195
关键字:

一维数组指针的用法