精华内容
下载资源
问答
  • c语言 二维数组指针
    2022-05-08 16:29:33

    前言

    前面我们讲了一维数组指针,今天我们讲一下二维数组指针。

    一、二维数组指针的定义:

    1. 概述: 二维数组指针的定义就是把一维数组换成二维数组。二维数组的各个元素也都是地址。
    2. 步骤:
      int a[2][3] = { {1,2,3},{4,5,6} }; / / 定义一个二维数组
      int (*p)[2][3] = &a; / / a 是整个二维数组的地址
      int (*p)[2][3] 为二维数组指针类型,p ==&a 所以(*p)的用法和 a 一样,a[1][1] == ( *p)[1][1];
    3. a[0] 和a[1] 是两个小数组的名字,所以 &a[0] , &a[1] 是一维数组类型 int (*)[3].在这里插入图片描述

    二、二维数组指针遍历数组元素:

    在这里插入图片描述
    二维数组指针与一维数组指针的遍历原理都相同,之前已经讲的很清楚了,大家可以回去再回顾一下。

    总结

    二维数组指针与一维数组指针的原理都大同小异,大家好好理解一下。

    更多相关内容
  • 二维数组在概念上是二维的,有行和列,但在内存中所有的数组元素都是连续排列的,...C语言中的二维数组是按行排列的,也就是先存放 a[0] 行,再存放 a[1] 行,最后存放 a[2] 行;每行中的 4 个元素也是依次存放。数组 a
  • 主要介绍了C语言二维数组指针指向问题,文中不建议用二级指针来访问二维数组,需要的朋友可以参考下
  • C语言中,二维数组的参数传递。 例如: char str[5][100]; 如果作为参数传递,内有详细示例。 三种传参示例供参考。
  • 有下面这样的一个二维表,请将其使用二维数组输出 姓名 语文 数学 英语 张三 80 70 90 李四 40 50 90 王五 90 98 100 题解 与几位童鞋交流了一下发现他们都把汉字单独拿出来了,只用数组存储的成绩,...
  • 二维数组在概念上是二维的,有行和列,但在内存中所有的数组元素都是连续排列的,它们之间没有“缝隙”。以下面的二维数组 a 为例: int a[3][4] = { {0, 1, 2, 3}...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



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

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

    4) *(*(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 个字节的内存。

    本文转载自:

    C语言二维数组指针(指向二维数组的指针)详解

    展开全文
  • 结合牛客刷到的一道经典题目,梳理总结C语言二维数组指针用法

    目录

    题目

    背景概念梳理

    一维线性

    数组指针

    指针步长

    数组名与指向其的指针变量名等价

    数组的初始化与取元素

    数组指针转换关系

    解题过程

    选项A:* (( * prt+1)[2])

    选项B:* ( * (p+5))

     选项C:( * prt+1)+2

    选项D: * ( * (a+1)+2)

    正确答案

    整体代码

    参考链接


    题目

    设有以下定义:

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

    则以下能够正确表示数组元素a[1][2]的表达式是()

    A. * (( * prt+1)[2])
    B. * ( * (p+5))
    C. ( * prt+1)+2
    D. * ( * (a+1)+2)

    链接:设有以下定义: a[4][3]={1,2,3,4,5,6__牛客网,来源:牛客网

    背景概念梳理

            以本题为例,二维数组a[4][3],所表示的元素排列如下:

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

            a[4][3]可理解为“一个四行三列的数组”,亦可理解为“数组a包含4个数组元素,每个数组元素包含三个整形元素”

    一维线性

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

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

    数组指针

    int (*prt)[3] = a;

            括号中的*表明 prt 是一个指针变量,它指向某数组,这个数组的类型为int [3](即这个数组是一个包含三个元素的数组),这正是 a 所包含的每个一维数组的类型。指针prt指向a的首个一维数组。

    指针步长

            prt是一个指向数组的指针,指针的步长取决于其指向的数据变量的大小,prt指向的是一个数组类型为int[3]的数组,那么其数据结构大小为(3*4)=12字节,即prt在当前情况下,步长为12,(prt+1),(prt-1),所指向的数据内存地址,各差12。

    数组名与指向其的指针变量名等价

            数组名表示数组的第一个元素的地址,可将其看作是一个指针常量。而这个指针常量所指向的类型与数组元素的类型一致。在本题中,prt作为指向数组a的第一个元素的地址的指针变量名,数组a的数组名"a"亦表示其数组的第一个元素的地址,两个都是指向数组a的第一个元素的地址,故数组名 a 在表达式中也会被转换为和 prt 等价的指针。

    数组的初始化与取元素

            以一维数组为例,初始化的时候"[]"中,所填的数值是要给数组分配几个元素的位置;取元素时,“[]”中,所填的数值是要获取那个索引值的元素,数组的索引值都是从零开始的。“[]”中所填的数值,在数组初始化和取元素时所表达的含义完全不一样。

    //初始化
    int num[5]; //数组 num 中有 5 个元素,每个元素都是 int 型变量,而且它们在内存中的地址是连续分配的 
    
    //取元素
    int n1 = num[0];//获取num数组的第零个元素
    int n2 = num[1];//获取num数组的第一个元素
    int n3 = num[2];//获取num数组的第二个元素
    int n4 = num[3];//获取num数组的第三个元素
    int n5 = num[4];//获取num数组的第四个元素
    

    数组指针转换关系

    int a[4][3];
    int (*p)[3] = a;
    
    //0<=i<=3, 0<=j<=2 
    a+i == p+i
    a[i] == *(a+i) //a[i]等价于从数组a的首地址向后数第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)

    解题过程

            依题,a[1][2]所对应的值是6,按选项逐个分析:

    选项A:* (( * prt+1)[2])

    *prt表示的是数组a第一个数组元素的地址=数组a的首地址,

    (*prt+1)表示数组a中第二个整形元素的地址(在这里prt发生了退化,指向的是数组a中的首个数组元素的首个整形元素,实际运行结果,*prt与(*prt+1)差4字节,可佐证),

    (*prt+1)[2]表示数组a第二个整形元素向后跨两个索引的值,

    * (( * prt+1)[2])表示数组a第二个整形元素向后跨两个索引的值作为指针变量所指向的变量,

    int main()
    {
    	int a[4][3] = {1,2,3,4,5,6,7,8,9,10,11,12};
    	int (*prt)[3] = a, *p = a[0];
    	
    	printf("a[1][2]: %d\n",a[1][2]); //[]的作用 
    
    	printf("\nA: *prt: %d\n",*prt);
    	printf("A:(*prt+1): %d\n",(*prt+1));
    	printf("A:(*prt+1)[2]: %d\n",(*prt+1)[2]);
    	//printf("*((*prt+1)[2]): %d\n",*((*prt+1)[2])); //直接报错 
    } 

            另外,做了一个关于指针退化的实验,*(prt+1)指向的是数组a的第二个数组元素(实验佐证,sizeof指针长度为12),但当再其基础上做加1处理后,其就退化成了指向第二行的首个数据的指针。

    		
        printf("\nAtry: *(prt+1): %d\n",*(prt+1));
    	printf("Atry: sizeof(*(prt+1)): %d\n",sizeof(*(prt+1))); //说明*(prt+1)获取的是第二行的数据
    	printf("Atry: *(prt+1)+1: %d\n",*(prt+1)+1);//*(prt+1)退化成了第二行的第一个数据的地址, 
    	printf("Atry: ((*(*(prt+1)+1)): %d\n",(*(*(prt+1)+1)));

            关于数组指针退化的问题,当直接对数组指针变量进行操作(eg. *(prt+1))后再解引用,都不会导致指针退化。除此之外,都会退化到指向某个整形元素。具体原因,*(prt+1)单独使用时表示的是第 1 行数据,放在表达式中会被转换为第 1 行数据的首地址,也就是第 1 行第 0 个元素的地址,因为使用整行数据没有实际的含义,编译器遇到这种情况都会转换为指向该行第 0 个元素的指针;就像一维数组的名字,在定义时或者和 sizeof、& 一起使用时才表示整个数组,出现在表达式中就会被转换为指向数组第 0 个元素的指针。

    选项B:* ( * (p+5))

    指针p直接指向的数组a的首个数组元素的首个整形元素,因为指针p的数据类型是int,

    *(p+5)表示从数组a的首个数组元素的首个整形元素向后数的第5个整形元素的指针所指向的值,

    *(*(p+5))表示从数组a的首个数组元素的首个整形元素向后数的第5个整形元素的指针所指向的值作为指针变量所指向的值(不存在嘛!直接报错)。

    	//printf("*(*(p+5)): %d\n",*(*(p+5))); //直接报错 
    	printf("\nB: (*(p+5)): %d\n",(*(p+5)));  
    	printf("B: (p+5): %d\n",(p+5));

     

     选项C:( * prt+1)+2

    *prt表示数组a的首个元素对应的地址

    (*prt+1)表示数组a的第二个元素对应的地址

    ( * prt+1)+2表示数组a的第4个元素对应的地址

    只有再在其基础上,再加一层解引用,才可以表示数组a的第4个元素对应的值

    	printf("\nC: *prt: %d\n",*prt);
    	printf("C: (*prt+1): %d\n",(*prt+1));
    	printf("C: (*prt+1)+2: %d\n",(*prt+1)+2);
    	printf("C: *((*prt+1)+2): %d\n",*((*prt+1)+2)); //只有再在其基础上,再加一层解引用,才可以表示数组a的第4个元素对应的值

     

    选项D: * ( * (a+1)+2)

    a等同于prt,

    *(a+1)表示数组a的第二个数组元素的地址,

    *(a+1)+2,发生指针退化,*(a+1)此时表示数组a的第二个数组元素中的首个整形元素的地址,整个表示数组a第二行的第二个元素的地址

    * ( * (a+1)+2)表示数组a第二行的第二个元素的值

    		
    	printf("\nD: *(a+1): %d\n",*(a+1));
    	printf("D: (*(a+1)+2): %d\n",(*(a+1)+2));
    	printf("D: *(*(a+1)+2): %d\n",*(*(a+1)+2));
    	
    	printf("\nD: *(a): %d\n",*(a));
    	printf("D: *(a+1): %d\n",*(a+1));
    	printf("D: *(*a+1): %d\n",*(*a+1));

     

    正确答案

    选D,* ( * (a+1)+2)

    整体代码

    int main()
    {
    	int a[4][3] = {1,2,3,4,5,6,7,8,9,10,11,12};
    	int (*prt)[3] = a, *p = a[0];
    	
    	printf("a[1][2]: %d\n",a[1][2]); //[]的作用 
    	
    	//printf("*((*prt+1)[2]): %d\n",*((*prt+1)[2]));
        printf("\nAtry: *(prt+1): %d\n",*(prt+1));
    	printf("Atry: sizeof(*(prt+1)): %d\n",sizeof(*(prt+1))); //说明*(prt+1)获取的是第二行的数据
    	printf("Atry: *(prt+1)+1: %d\n",*(prt+1)+1);//*(prt+1)退化成了第二行的第一个数据的地址, 
    	printf("Atry: ((*(*(prt+1)+1)): %d\n",(*(*(prt+1)+1)));
    		
    	printf("\nA: *prt: %d\n",*prt);
    	printf("A:(*prt+1): %d\n",(*prt+1));
    	printf("A:(*prt+1)[2]: %d\n",(*prt+1)[2]);
    	//printf("*((*prt+1)[2]): %d\n",*((*prt+1)[2])); //直接报错 
    	
    	
    	//printf("*(*(p+5)): %d\n",*(*(p+5))); //直接报错 
    	printf("\nB: (*(p+5)): %d\n",(*(p+5)));  
    	printf("B: (p+5): %d\n",(p+5));
    	
    	
    	printf("\nC: *prt: %d\n",*prt);
    	printf("C: (*prt+1): %d\n",(*prt+1));
    	printf("C: (*prt+1)+2: %d\n",(*prt+1)+2);
    	printf("C: *((*prt+1)+2): %d\n",*((*prt+1)+2)); //只有再在其基础上,再加一层解引用,才可以表示数组a的第4个元素对应的值
    	
    		
    	printf("\nD: *(a+1): %d\n",*(a+1));
    	printf("D: (*(a+1)+2): %d\n",(*(a+1)+2));
    	printf("D: *(*(a+1)+2): %d\n",*(*(a+1)+2));
    	
    	printf("\nD: *(a): %d\n",*(a));
    	printf("D: *(a+1): %d\n",*(a+1));
    	printf("D: *(*a+1): %d\n",*(*a+1));
    } 

    参考链接

    数组的定义,初始化和使用,C语言数组详解数组可以说是目前为止讲到的第一个真正意义上存储数据的结构。虽然前面学习的变量也能存储数据,但变量所能存储的数据很有限。不仅如此,数组和指针(后续会讲)是相辅相成的http://c.biancheng.net/view/184.html

    C语言二维数组指针(指向二维数组的指针)详解二维数组在概念上是二维的,有行和列,但在内存中所有的数组元素都是连续排列的,它们之间没有缝隙。以下面的二维数组 a 为例: int a[3][4] = { {0, 1, 2, 3}, {4, 5, 6, 7}, {8, 9, 10, 11} }; 从http://c.biancheng.net/view/2022.html

    展开全文
  • c语言中经常需要通过函数传递二维数组,有三种方法可以实现,如下: 方法一, 形参给出第二维的长度。 例如: #include void func(int n, char str[ ][5] ) { int i; for(i = 0; i < n; i++) printf("/nstr...
  • 二维数组在概念上时二维的,有行和列,但在内存中所有的数组元素都时连续排列的,它们之间没有“缝隙”。以下面的二维数组 a 为...c语言中的二维数组时按行排列的,也就是先存放a[0]行,在存放a[1]行,最后存放a[2]行.

    二维数组在概念上时二维的,有行和列,但在内存中所有的数组元素都时连续排列的,它们之间没有“缝隙”。以下面的二维数组 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个字节,整个数组共占用4x(3x4)=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就成了一个指针数组,而不是二维数组指针。

    对指针进行加法(减法)运算时,它前进(后退)的步长与它指向的数据类型有关,p指向的数据类型是int[4],那么p+1就前进4x4=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

    3)*(p+1)+1表示第1行第1个元素的地址。

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

    4)*(*(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 mian(){
        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

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

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

    展开全文
  • C语言中,指针是一个复杂但又灵活多变的知识点,我们知道,在一维数组中,对于一个数组a[],*a,a,&a,都表示a的首地址,但如果与二维数组混合使用,就显得更为复杂了。例如对于一个二维数组 a[2][4]={{1,2.3},{4...
  • (2)、第二种是用一维数组来表示二维数组,从显示的元素地址可以看出,二维数组和一维数组表示的二维数组在内存中的储存方式其实是一样的,不过使用二维数组看起来要简单些,只要不用进行地址转换。 (3)、第三...
  • C语言二维数组指针引用

    千次阅读 2022-04-11 15:40:58
    文章目录C语言二维数组指针引用1.二维数组的定义与表示2.用指针引用二维数组元素 C语言二维数组指针引用 1.二维数组的定义与表示 二维数组是形如: 表示一个int类型,三行四列的数组 int a[3][4]={1,2,3,4,5,6,7...
  • c语言指针的应用 #include <...传递的时候给一个二维数组的名字即可,数组的名字可以被当成是指向第一个元素的指针 void search(int *,int *,int array[24][7],int key); //函数print_row_i的第一个参数.
  • C语言数组指针二维数组中的使用 二维数组传参,传的数组名其实是一个数组指针,一维数组传参,传的是数组首元素的地址 贴上代码: #include <stdio.h> void print1(int arr[][4], int row, int col) '...
  • 彻底理解C语言二维数组指针

    千次阅读 多人点赞 2020-06-07 13:43:56
    C语言二维数组以及用指针操作相对于一组数组而言有些复杂,这里尝试通过类比的方式快速理解。 首先我们要理解一组数组以及其指针操作方法。比如定义数组:int a[10],则a为数组第0个元素的地址,即:a ==&a[0...
  • 一、对于二维数组指针偏移的运算法则。同一维数组一样,二维数组的数组名也是指向第一个数组元素的(即Array等于&Array[0][0]),且二维数组的数组元素在计算机内的内存存放也是连续的,但不一样的是:Array+1的...
  • #include float stu_ave(int *p,int n) //接收列地址,和元素个数{int i;...//p[i] p是一个列地址 把二维看成一个一维数组所以就是P[i] 来进行遍历每个元素return sum/n;}int *stu_find(int (*p)[4],int n...
  • C语言二维数组指针,字符数组指针输出程序实例(注释详细)
  • 一、初始化 必须指定列的数量,行的数量可以不定义 1.分行进行初始化 定义一个2×3的数组 int a[2][3]={{1,2,3},{4,5,6}}; 2.不分行初始化 定义一个2×3的数组 int a[2][3]={1,2,3,4,5,6};...
  • 同样的道理,arr是二维数组名时,*arr也是取arr的第一个元素,但是此时arr所指的元素是一个一维数组,所以,实际上arr所指元素是一维数组的首地址。就按arr[3][4]这个例子来看:3行4列数组arr可以理解为arr[0],arr[1...
  • C语言 二维数组指针

    千次阅读 多人点赞 2019-06-14 17:21:55
    二维数组可以看成是元素为一维数组的数组,假设有一个三行四列的二维数组a,它定义为: int a[3][4] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 }; a 是二维数组名。a 数组包含 3 行,即 3 个行元素:a[0],a[1]...
  • C语言二维数组指针

    2019-09-12 16:27:53
    a为a[2][3]的数组名,二维数组指针,指向的是一维数组 而a[0]数组的指针,是单个元素a[0][0];一维数组的指针,指向的是单个元素 虽然a[0]与a的首地址都是a[0][0],但是随着指针的偏移,a每次偏移12B,而a[0]每次...
  • 二维数组:char a[2][3];二维数组实质上也就是一维数组,a[2][3]可看做一个2个元素的一维数组,这2个元素又是另一个数组,在内存中,它的排布如下: #include "stdio.h"int main(int argc, char *argv[]){char a[2]...
  • printf("第行第个元素*(*(s+1)+2)=%c\n",*(*(s+1)+2)); len =sizeof(a)/sizeof(a[0]); for( i=0;i { printf("%c\n",*(*(s+0)+i)); //printf("%c\n",s[0][i]); } temp = stringCom(s,len); } char * stringCom...
  • 二维数组指针访问—— 王炳华指向二维数组指针及用指针访问二维数组,是学习指针的最大难点。如果真正弄懂了这个问题,就可以说你学会了使用指针。一、二维数组指针指针就是地址,二维数组指针就是二维数组...
  • C语言二维数组传参问题

    千次阅读 2020-02-01 11:07:56
    维数组传参 我们知道,在C语言中,当数组作为实参进行传递时,本质上就是指针在做实参(传递地址值)。如下所示 /* 打印数组的元素值 */ void printArr(int* arr,int len){ for (int i = 0; i<len; i++) { ...
  • #include void print(int(*p)[5], int x, int y) { for (int i = 0;...//parr2是一个指针,指向一个10个元素的整型数组。 int(*parr3[10])[5];//parr3是一个有10个元素数组,每个元素都是一个指向5个元素的整型数组

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 42,849
精华内容 17,139
关键字:

c语言二维数组指针