精华内容
下载资源
问答
  • 函数指针、函数名、二维数组指针做形参时的要注意的地方
  • 二维数组指针详解

    2018-01-20 15:00:54
    详细讲述了二维数组与指针之间的联系,对于学习C语言,理解指针数组吗,数组指针,数组与指针之间的关系有重要的帮助。仔细学习完该文档,详细你不会再为指针和数据而困惑。
  • 二维数组指针表示,C语言指针引用二维数组详解

    千次阅读 多人点赞 2019-12-09 14:43:53
    指针变量可以指向一维数组中的元素,当然也就可以指向二维数组中的元素。但是在概念和使用方法上,二维数组指针比一维数组的指针要复杂一些。要理解指针二维数组的关系首先要记住一句话:二维数组就是一维数组,...

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

    假如有一个二维数组:

    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* 型从心理上或从感觉上都更容易接受。

    展开全文
  • 主要介绍了C++指针数组、数组指针、数组名及二维数组技巧汇总,对于深入理解C++数组与指针来说非常重要,需要的朋友可以参考下
  • C语言二维数组指针(指向二维数组的指针)详解

    万次阅读 多人点赞 2020-05-27 17:43:22
    如有需要,请访问C语言二维数组指针(指向二维数组的指针)详解 二维数组在概念上是二维的,有行和列,但在内存中所有的数组元素都是连续排列的,它们之间没有“缝隙”。以下面的二维数组 a 为例: int a[3][4] = { ...

    声明!本文转载仅为方便学习使用!
    如有需要,请访问
    C语言指针数组(数组每个元素都是指针)详解
    C语言二维数组指针(指向二维数组的指针)详解

    二维数组在概念上是二维的,有行和列,但在内存中所有的数组元素都是连续排列的,它们之间没有“缝隙”。以下面的二维数组 a 为例:

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

    从概念上理解,a 的分布像一个矩阵:

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

    但在内存中,a 的分布是一维线性的,整个数组占用一块连续的内存:
    二维数组在内存中的存储

    C语言中的二维数组是按行排列的,也就是先存放 a[0] 行,再存放 a[1] 行,最后存放 a[2] 行;每行中的 4 个元素也是依次存放。数组 a 为 int 类型,每个元素占用 4 个字节,整个数组共占用 4×(3×4) = 48 个字节。

    C语言允许把一个二维数组分解成多个一维数组来处理。对于数组 a,它可以分解成三个一维数组,即 a[0]、a[1]、a[2]。每一个一维数组又包含了 4 个元素,例如 a[0] 包含 a[0][0]、a[0][1]、a[0][2]、a[0][3]

    假设数组 a 中第 0 个元素的地址为 1000,那么每个一维数组的首地址如下图所示
    在这里插入图片描述
    为了更好的理解指针和二维数组的关系,我们先来定义一个指向 a 的指针变量 p:

    int (*p)[4] = a;
    

    括号中的*表明 p 是一个指针,它指向一个数组,数组的类型为int [4],这正是 a 所包含的每个一维数组的类型。

    [ ]的优先级高于*,( )是必须要加的,如果赤裸裸地写作int *p[4],那么应该理解为int *(p[4])p 就成了一个指针数组,而不是二维数组指针,这在《C语言指针数组》中已经讲到。
    对指针进行加法(减法)运算时,它前进(后退)的步长与它指向的数据类型有关,p 指向的数据类型是int [4],那么p+1就前进 4×4 = 16 个字节,p-1就后退 16 个字节,这正好是数组 a 所包含的每个一维数组的长度。也就是说,p+1会使得指针指向二维数组的下一行,p-1会使得指针指向数组的上一行。

    数组名 a 在表达式中也会被转换为和 p 等价的指针!

    下面我们就来探索一下如何使用指针 p 来访问二维数组中的每个元素。按照上面的定义:

    1. p指向数组 a 的开头,也即第 0 行;p+1前进一行,指向第 1 行。

    2. *(p+1)表示取地址上的数据,也就是整个第 1 行数据。注意是一行数据,是多个数据,不是第 1 行中的第 0 个元素,下面的运行结果有力地证明了这一点:

    #include <stdio.h>
    int main(){
        int a[3][4] = { {0, 1, 2, 3}, {4, 5, 6, 7}, {8, 9, 10, 11} };
        int (*p)[4] = a;
        printf("%d\n", sizeof(*(p+1)));
        return 0;
    }
    

    运行结果:

    16
    
    1. *(p+1)+1表示第 1 行第 1 个元素的地址。如何理解呢?

    *(p+1)单独使用时表示的是第 1 行数据,放在表达式中会被转换为第 1 行数据的首地址,也就是第 1 行第 0 个元素的地址,因为使用整行数据没有实际的含义,编译器遇到这种情况都会转换为指向该行第 0 个元素的指针;就像一维数组的名字,在定义时或者和 sizeof& 一起使用时才表示整个数组,出现在表达式中就会被转换为指向数组第 0 个元素的指针。

    1. *(*(p+1)+1)表示第 1 行第 1 个元素的值。很明显,增加一个 * 表示取地址上的数据。

    根据上面的结论,可以很容易推出以下的等价关系:

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

    实例】使用指针遍历二维数组。

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

    运行结果:

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

    指针数组和二维数组指针的区别

    针数组和二维数组指针在定义时非常相似,只是括号的位置不同:

    int *(p1[5]);  //指针数组,可以去掉括号直接写作 int *p1[5];
    int (*p2)[5];  //二维数组指针,不能去掉括号
    

    指针数组和二维数组指针有着本质上的区别:指针数组是一个数组,只是每个元素保存的都是指针,以上面的 p1 为例,在32位环境下它占用 4×5 = 20 个字节的内存。二维数组指针是一个指针,它指向一个二维数组,以上面的 p2 为例,它占用 4 个字节的内存。

    二维数组名做参数传递问题

    展开全文
  • 可以看到,实质上二维数组在物理上是连续存储的,但是分析二维数组指针的时候更应该分析二维数组的逻辑结构,如下所示: 应当看到,二维数组的在逻辑上是多个行数个一维数组的集合,这种理解方式至关重要。 在这种...

    先看一个例子:

    int a[3][4];
    int (*p)[4]=a;
    *(p[0]+2)=2;//这句话是什么意思
    

    首先,我们必须明白二维数组的逻辑结构和物理结构
    这是物理结构
    可以看到,实质上二维数组在物理上是连续存储的,但是分析二维数组指针的时候更应该分析二维数组的逻辑结构,如下所示:
    二维数组逻辑结构
    应当看到,二维数组的在逻辑上是多个行数个一维数组的集合,这种理解方式至关重要。

    在这种观点之下,我们来看一个问题。即a[0]的含义是什么?既然二维数组可以看做行数个一维数组的集合,那么a[0]是不是可以看做是一维数组的数组名?回忆我们用下标来指示数组的方式:a[0][1],是不是就是在a[0]当成数组名?那么我们就又要注意到,如果a[0]的含义是数组名,那么是否也像一维数组那样,可以当做该一维数组的首地址?答案是肯定的。即此刻我们可以认为,在二维数组中,a[i]存放着该行数组的首地址,那么,* (a[0]+2)的含义就很明显了。
    我们可以对 *(a[0]+2)这个式子采用这样的理解方式:我们设定第0行的行数组为数组b,那么此刻a[0]的含义就是b的数组名b,那么原式子可以理解为 *(b+2)。即b这一数组的第三个元素(下标从0开始)即 * (a[0]+2)= * (b+2)=b[2]=a[0][2].
    理解了a[i]是第i行数组的首地址的问题之后,我们再回到开头的那个问题。

    int (*p)[4]=a;
    *(p[0]+2)=2;//这句话是什么意思
    

    首先明确,int (*p)[4]=a;中的p是二维数组指针。与之对应的是指针数组int *p[4]。
    如何区分和记忆?我们记得,[]的优先级是很高的,于是int * p[4]中的p和[4]是密不可分的,这就意味着这里的p是一组数组的名字,而数组的类型是指针;与之对应的是int * §[4],这里p是二维数组的指针。
    二维数组的指针是什么?直观来看,和一维数组类似,用以指向整个二维数组。
    在这里插入图片描述
    就是这个图里的a。但是由于其是一个数组指针,所以要注意,它每次加1的步进值是4个数组单元。这就要回到逻辑上的二维数组结构了。
    在这里插入图片描述

    一般,我们会将二维数组的名字赋给数组指针p。p所指向的正是之前我们提到过的a[0]。而p+i指向的正是a[i]。那么**上面我们说过了,a[i]实质上是对应行的数组名字,也即该数组的地址,也是该行数组的指针。**那么可以看到,**这里p+i是指向第i行数组地址的指针,也就是第i行数组地址的地址。**既然是地址的地址,那么显而易见,需要两次解引用才可以取到数组中的某个元素。
    最常见的用法像是这样:
    *( *(p+i)+j)。我们来分析这个操作。首先是 *(p+i),这里 (p+i)==a[i]。但是注意了,反复强调过a[i]是i行数组的数组名,所以也可以理解为 (p+i)==a[i]=b;其中b是我们假定的第i行的数组名。那么将b代入这个式子可以看到原来的式子为:
    (b+j)。这个式子是不是就很好理解?就是b这个数组的第j号元素嘛。而b这个数组是a的第i行数组,于是很容易知道,绕了半天,( (p+i)+j)=a[i][j]。
    但是我们离开头的问题似乎还是差一点。这个
    (p[0]+2)=2;中的p[0]是什么呢?这里其实可以从两个方面理解,一个,可以将p和a一起来看,那么p[0]==a[0],那么a[0]+2指的就是第0行第2号元素的地址,外面加个解引用的符号即是取第0行的第2号元素。另外一个理解是p[0]等价于 *(p+0),再结合刚才的分析,那么就可以理解了。

    上面说了基本的原理,下面提炼下分辨的要点:

    1. int *p[4]是二维数组指针,表示的实际是二维数组的首地址,也是该二维数组中的一维数组的地址的地址。
    2. int (*p)[4]是指针数组。实质是元素为指针的一维数组。
    3. 分析二维数组时,如果出现了二维数组指针,那么取某个元素的时候要两次解引用,或者利用p[0]这样的形式做一个默认的转换。
    展开全文
  • 二维数组与指针、指针数组、数组指针的用法

    万次阅读 多人点赞 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,返回的是数组的总空间

    展开全文
  • c++二维数组指针详解

    千次阅读 2020-04-13 10:42:13
    int main() { int a[3][4]={{1,2,3,4},{5,6,7,8},{9,10,11,12}};... //上面可以这么理解:对于一维数组a[],数组名a是第一个元素a[0]的地址,那么对于二维数组a[][],一维数组名a[0]是它的第一个元素a[0][...
  • (2)、第二种是用一维数组来表示二维数组,从显示的元素地址可以看出,二维数组和一维数组表示二维数组在内存中的储存方式其实是一样的,不过使用二维数组看起来要简单些,只要不用进行地址转换。 (3)、第三...
  • 主要介绍了C++中用new创建二维数组指针数组实例代码,非常不错,具有参考借鉴价值,需要的朋友参考下
  • 概念详解:指针指针与“int a”,...一维数组:定义一维数组之后,即在内存中分配一段连续的地址空间,如C语言中,int num[5],在32位系统中,int占据4个字节,现假设num[0]的地址空间为0x00000004,那么num[...
  • 二维数组在概念上是二维的,有行和列,但在内存中所有的数组元素都是连续排列的,它们之间没有“缝隙”。以下面的二维数组 a 为例: int a[3][4] = { {0, 1, 2, 3}, {4, 5, 6, 7}, {8, 9, 10, 11} }; 从概念上理解...
  • 二维数组数组指针详解

    多人点赞 2020-07-26 18:18:53
    二维数组 深入理解二维数组 首先定义一个二维数组 int a[2][3]={{1,2,3},{4,5,6}}; #or int a[2][2]={1,2,3,4}; 新的理解:我们可以这样认为,a可以看作是一个一维数组,包含2个元素,每个元素恰好是包含3个整型...
  • 1、用指针数组表示二维数组 char ch[2][3] = {"aa","bb"}; char *p[2]; int i; for(i=0;i<2;i++) { p[i] = ch[i]; } ...2、用数组指针表示二维数组 char ch[2][3] = {"aa","bb"}; ...
  • 用于比较指针数组和数组指针实现算法的差异,利用函数返回指针实现。 可作为研究C语言指针使用的范例程序。 有源代码和实现结果图。
  • 文章目录一维数组指针和二维数组指针的定义一维数组指针和二维数组指针用于索引数组元素一维数组指针和二维数组指针的可视化解读 一维数组指针和二维数组指针的定义 一维数组指针的定义就是普通指针的定义 指针变量...
  • 关于用指针方式访问二维数组的问题 首先说明几种类型: int a[2][4] = { 1,2,3,4,5,6,7,8 };//二维数组 int **p; //二重指针跨度为sizeof(int *) int(*q)[4]; //该语句是定义一个指向数组的指针,指向含4个...
  • 指针表示二维数组的4种方式

    千次阅读 2020-12-26 15:41:52
    剧情回顾:12/25 周五,华老师说如果能自己写出来4种方式,就因该掌握了,指针数组方面的应用。于是有了,这篇文章,文章的内容会同步到《指针(心路历程)》这篇博客中。 1. 列指针 ...//如何用指针表示.
  • 二维数组指针表示

    2016-05-28 23:41:21
    见下图
  • 主要介绍了C语言二维数组指针指向问题,文中不建议用二级指针来访问二维数组,需要的朋友可以参考下
  • 对于二维数组 二级指针以及数组指针的讨论。对于二维数组 二级指针以及数组指针的讨论
  • c/c++ 二维数组指针参数传递 矩阵计算实例

    千次阅读 多人点赞 2019-03-30 00:57:19
    今天我将试图用沙雕文风解释二维数组的知识;D 1问题 首先我们来看一下问题 FBIwarning:建议在阅读答案前,独立思考,先自行尝试,遇到问题再继续阅读。 怎么样!看起来就很难对吧!实际上!它确实不...
  • 二维数组指针

    千次阅读 2019-04-04 18:47:25
    int a[5]={1,2,3,4,5}; int *p=(int *)(&...本身a作为一个地址,p作为指向a的地址,相当于一个二维指针, 一个二维指针加一相当于移动了一行,所以这里是移动了5*4个字节,而对于q+1的情况,说明移动了4个字节...
  • C语言中二维数组要用Int** 来表示,在分配空间后,int**加一会移动到下一行。而m行n列的二维数组的寻址方式是首地址a+in+j,因此先对a+i找到相应的行,也就是一维数组,并且取得到一个int指针,再加上j,再取值即为...
  • 二维数组指针问题

    2019-08-15 09:27:33
    编写一个程序,初始化一个double类型的3×5二维数组,使用一个处理变长数组的函数将其拷贝至另一个二维数组中。还要编写一个以变长数组为形参的函数以显示两个数组的内容。这两个函数应该能处理任意N×M数组。(《C ...
  • c语言中经常需要通过函数传递二维数组,有三种方法可以实现,如下: 方法一, 形参给出第二维的长度。 例如: #include void func(int n, char str[ ][5] ) { int i; for(i = 0; i < n; i++) printf("/nstr...
  • 利用数组指针p将main函数中输入的二维数组a的所有元素输出, 要求先按行的顺序输出,然后再以列的顺序输出, 其中输出整型格式用 “%3d”, (测试用数据大小不要超过2位数)。 函数接口定义: void reOut(int (*p)[3]...
  • a[3][4] = {1,2,3,4,5,6,7,8,9,10,11,12}; int *p = a; //普通指针 int (*p)[4] = a; //数组指针 int *p[4]; //指针数组 1、普通指针 int *p=a,p实际上表示的就是a[0]...2、数组指针:指向数组的指针 int (*p...
  • 9#include using namespace std; int main() { void fun(int *p1,int *p2,int w,...这个程序中,p1[i*w+j]代表啥啊,是二维数组的表达方式? 那当i=1时,表示P1[2+0],这不就是P1【2】【0】吗,那P1【1】【0】咋表示

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 107,352
精华内容 42,940
关键字:

二维数组指针表示