精华内容
下载资源
问答
  • 二维数组在概念上是二维的,有行和列,但在内存中所有的数组元素都是连续排列的,它们之间没有“缝隙”。以下面的二维数组 a 为例: int a[3][4] = { {0, 1, 2, 3}, {4, 5, 6, 7}, {8, 9, 10, 11} }; 从概念上理解...
  • 此文描述了数组指针与二维数组的寻址的相关内容,具体内容请看下面  引例:已知如下程序  1 #include  2 main()  3 {  4 int x[3][4] = {1,3,5,7,9,11,2,4,6,8,10,12} ;  5 int (*p)[4] =...
  • 指针与二维数组

    千次阅读 多人点赞 2018-06-10 19:28:19
    二维数组的本质 double matrix[3][4]; doublematrix[3][4]; =>double[4] matrix[3]; 令type为double[4],所以double[4] matrix[3]为typematrix[3],这说明,matrix是一个一维数组,有3个元素;每个元素是type...

    二维数组的本质

        double matrix[3][4];

     double matrix[3][4];    =>double [4] matrix[3];    令type为double [4],所以double [4] matrix[3]为type matrix[3],这说明,matrix是一个一维数组,有3个元素;每个元素是type,即double [4]类型的。

     

    matrix是什么?

     

        &matrix[0][0]    这个操作的意思是取二维数组第0行,第0列(即整个二维数组的第一个元素)的首地址;

        &matrix[0][0]    <=>    &( matrix[0][0] )    <=>    &( ( matrix[0] ) [0] )    <=>    &( (*(matrix + 0)) [0] )

        <=>    &( (*matrix) [0] )    <=>    &( *((*matrix) + 0) )    <=>    &( **matrix )    <=>    &**matrix

        <=>    *matrix

    上述一段推理证明&matrix[0][0]就是*matrix,下来,用一段程序证明这个结论:

     

    #include <stdio.h>
    
    int main() {
    	double matrix[3][4];
    	
    	printf("%p %p\n", *matrix, &matrix[0][0]);
    	
    	return 0;
    } 

    运行结果如下:

    上述结果证明:&matrix[0][0]就是*matrix。

    回顾一下一维指针:

    #include <stdio.h>
    
    int main() {
    	double  array[10];
    	double *p = NULL;
    	
    	p = array;	//p = &array[0] <=> p = &(*(array+0)) <=> p = &*array <=> p = array
    	
    	printf("%p %p %p\n", p, array, &array[0]);
    	printf("%p %p\n", p+1, array+1);	//p,array指类都是double类型 
    	
    	return 0;
    }  

    运行结果如下:

    结果说明,一维数组array的指类是double类型,array+1等于移动了一个指类的长度(即double,8个字节的长度)。

     

    再看一下二维数组:

    #include <stdio.h>
    
    int main() {
    	double matrix[3][4];	//等价于double[4] matrix[3]
    	
    	printf("%d\n", sizeof(double[4])); 
    	printf("matrix:%p     &matrix[0][0]:%p\n", matrix, &matrix[0][0]);
    	printf("matrix+1:%p   &matrix[0][0]+1:%p\n", matrix+1, &matrix[0][0]+1);	//matrix指类为double[4],matrix[0][0]为double 
    	printf("*matrix+1:%p  &matrix[0][0]+1:%p\n", *matrix+1, &matrix[0][0]+1);	// &matrix[0][0]等价于 *matrix
    	
    	return 0;
    } 

    运行结果如下:

    对每一个输出做出解释:第二行的输出地址相同,给我们一个假象:matrix和&matrix[0][0]是相同的,但是通过+1操作得到的输出地址表示,matrix+1移动了20h(即32个字节),&matrix[0][0]+1移动了8个字节,这是因为matrix和&matrix[0][0]的指类是不同的,matrix的指类是double[4],matrix[0][0]的指类是double。第三行的结果进一步证实了我们前面的推理,即:&matrix[0][0]就是*matrix,他们的指类都是double。

    进一步讨论:

    #include <stdio.h>
    
    int main() {	
    	double matrix[3][4];
    	
    	scanf("%lf", &matrix[0][0]);
    	printf("matrix[0][0]:%lf\n", matrix[0][0]);
    	
    	return 0;
    }  

    上面这个程序,在dev和gcc下运行都是没有问题的。但是

    #include <stdio.h>
    
    int main() {	
    	double matrix[3][4];
    
    	scanf("%lf", matrix);
    	printf("matrix:%lf\n", matrix[0][0]);
    	
    	return 0;
    } 

    这段程序在dev下运行没有问题,gcc下运行就出现了警告

    这段警告的意思是说,scanf("%lf", matrix);这段程序的第一个参数是double *类型,而第二个参数是double (*)[4]类型的,进一步说明了matrix和&matrix[0][0]的指类是不同的。

    double[4] matrix[3];    =>    double matrix[3][4];

    double[4] *matrix;    =>    double *matrix[4];    这样的写法和上述表示不能等价,因为,[]优先与matrix结合,造成matrix与*的结合顺序发生更改,原来double[4] *matrix这样的写法强调的是*matrix的紧密结合,所以,为了与原来的写法等价,应该这样写:double (*matrix)[4]; 若忽略matrix变量名称,就出现了double(*)[4]的写法,诶,此时,我们发现,这个和刚才gcc的警告的写法一致了。

    综上,对于二维数组可以得到如下的结论了:

    double matrix[3][4]    二维数组名称matrix的类型是double(*)[4],其指类是double[4],因此,matrix+1会移动32B!!!

     

    matrix和*matrix和&matrix[0][0]和&matrix的关系

    一、关于matrix

    matrix是二维数组名称,指类是double[4],matrix+1将移动32B。

    二、关于*matrix:

        *matrix    <=>    *(matrix)    <=>    *(matrix + 0)    <=>    matrix[0]

    那么,matrix[0]、matrix[1]······matrix[n]是什么意思呢?

    &matrix[0][0]    <=>    *matrix    <=>    matrix[0]

    &matrix[1][0]    <=>    &( (matrix[1]) [0] )    <=>    &*(matrix[1] + 0 )    <=>    matrix[1]

    ······

    &matrix[i][0]    <=>    &( (matrix[i]) [0] )    <=>    &*(matrix[i] + 0 )    <=>    matrix[i]

    二维数组名称,引用二维数组元素的过程:

     

    *matrix,对指针进行*运算,将产生“降阶”的效果,“*二阶指针”的类型就是“一阶指针”

    matrix本身的指类是double[4],降阶后成为double,这等于说*matrix的指类就是double!!!

     

    1、matrix[i][j]    <=>    (*(matrix+i))[j]

     

    *(matrix+i)中:matrix+i将移动i * sizeof(double[4])字节空间,即跳跃i行元素!然后*对其进行降阶,使*(matrix+i)的指类成为double,即matrix[i]是指针,指向下标为i的那一行的首地址。只是,其指类已经变成了double!

    2、(matrix[i])[j]    <=>    *( (matrix[i]) + j)

    (matrix[i]) + j事实上移动了j * sizeof(double)个字节空间,即在行内移动了j个double元素空间。

    上述二维数组名称matrix与其对应的指针变量,统称“行指针”。

    matrix+i即表示在行间移动。

    matrix[i]与其对应的指针变量,统称“列指针”。

    matrix[i]+j即表示在列间移动。

    三、关于&matrix[0][0]

    与*matrix是一个意思,只是表示不同。

    四、关于&matrix

    因为matrix的类型是double [3][4],因此,&matrix的指类就是double [3][4],那么:&matrix+1就应该移动sizeof(double [3][4])个字节,即96个字节!

    #include <stdio.h>
    
    int main() {	
    	double matrix[3][4];
    	
    	printf("&matrix:%p\n&matrix+1:%p\n", &matrix, &matrix+1);
    	
    	return 0;
    }  

    运行结果如下:

    展开全文
  • 二级指针与二维数组

    2019-08-10 22:19:38
    二级指针与二维数组容易搞混,二级指针做函数参数
    • 二级指针:
      指向指针变量的指针

    • 二级数组
      例如对于二维数组a[3][4],应该注意的是用矩阵表示二维数组是逻辑上的概念,能形象地表示出列关系.而在内存中,各元素都是连续地存放的,地址不是的,而是线性的.
      如下图所示:
      在这里插入图片描述

    因此二维数组不同于二级指针,由定义反而可以知晓,二维数组是可以当成一维数组对待的.

    看这个面试题目:

    void func1(int **a)
    {
    	printf("a[0][0]=%d\n", a[0][0]);
    	printf("a[0][1]=%d\n", a[0][1]);
    	printf("a[1][0]=%d\n", a[1][0]);
    	printf("a[1][1]=%d\n", a[1][1]);
    }
    
    void fun2(int *a)
    {
    	printf("a[0][0]=%d\n", a[0]);
    	printf("a[0][1]=%d\n", a[1]);
    	printf("a[1][0]=%d\n", a[2]);
    	printf("a[1][1]=%d\n", a[3]);
    }
    
    
    
    
    
    
    void main_01()
    {
    	int a[2][2] = { 0, 1, 2, 3 };
    	func1(a);   // 运行会报错
    	fun2(a);    // 正确
    
    	system("pause");
    	return;
    }
    

    分析原因:

    当把二维数组名a作为实参传入func1时,参数传进去的只不过是二维数组元素的首地址;此时指针实则退化成为一级指针了,即二维数组当成了一维数组对待
    二维数组地址本身是线性的,要想当成矩阵来使用,必须知道数组的列元素个数,但是列信息并没有传入给func1
    所以此时想按照二维数组的方式输出原数组的内容是不可能的,因为列信息丢失了,但是如果按照一维数组输出是可以的.


    那么如果我仍想希望可以按照二维数组输出呢?由上述分析可知,只需要传入列元素信息的指针即可,此时需要用到指向一维数组的指针变量,这才是二维数组对应的指针形式,而不是二级指针.

    void func3(int (*a)[2])
    {
    	printf("a[0][0]=%d\n", a[0][0]);
    	printf("a[0][1]=%d\n", a[0][1]);
    	printf("a[1][0]=%d\n", a[1][0]);
    	printf("a[1][1]=%d\n", a[1][1]);
    }
    

    参考博客:
    https://blog.csdn.net/u010275850/article/details/49556399

    展开全文
  • C语言指针与二维数组

    千次阅读 多人点赞 2019-09-04 21:26:17
    二维数组在概念上是二维的,有行和列,但在内存中所有的数组元素都是连续排列的,它们之间没有“缝隙”。以下面的二维数组 a 为例: int a[3][4] = { {0, 1, 2, 3}, {4, 5, 6, 7}, {8, 9, 10, 11} }; 从概念上理解,...

    二维数组在概念上是二维的,有行和列,但在内存中所有的数组元素都是连续排列的,它们之间没有“缝隙”。以下面的二维数组 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 *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]);	// 使用数组直接索引
    }
    
    展开全文
  • 利用数组指针p将main函数中输入的二维数组a的所有元素输出, 要求先按行的顺序输出,然后再以列的顺序输出, 其中输出整型格式用 “%3d”, (测试用数据大小不要超过2位数)。 函数接口定义: void reOut(int (*p)[3]...
  • 只有6行代码,非常简洁,这是char二级指针给char二维数组赋值的逻辑。二级指针需要先赋值操作,加断点就可以看见二维数组里的值了。
  • 指向指针指针与二维数组的区别

    千次阅读 2018-07-07 14:06:56
    int main(){ int a[2][3]={{1,2,3},{4,5,6}};... 由于p是指向指针指针,p指向一个int *类型的变量,而数组名a表示数组首元素的地址&amp;a[0],因此p指向a[0]。然而a[0]并不是int *类型的变量,p应...
  • 指针:C语言二级指针与二维数组

    千次阅读 2019-04-09 21:25:59
      最近用C语言写LeetCode 有的题目给的函数把二维数组用二级指针传进来 并传入行数和列数 引起一些疑惑 本来以为C语言学得海星,查了一些资料后,觉得自己还是个弟弟 : ( 按一维数组的思路处理二维数组,将二维...
  • C语言二重指针与二维数组

    千次阅读 2019-07-23 21:51:28
    设有一个二维数组a,它有3行4列。它的定义为: int a[3][4]={{1,3,5,7},{9,11,13,15},{17,18,21,23}}; a是一个数组名。a数组包含3行,即3个元素:a[0],a[1],a[2]。而每一元素又是一个一维数组,它包含4个元素...
  • 本文将详细讲解数组指针二维数组的知识。
  • c语言之二重指针与二维数组

    千次阅读 2018-05-06 12:16:25
    常量不能再取地址了, 二重指针赋值的时候不仅要看层次上 二重指针的两个用法
  • 用于比较指针数组和数组指针实现算法的差异,利用函数返回指针实现。 可作为研究C语言指针使用的范例程序。 有源代码和实现结果图。
  • 利用数组指针p将main函数中输入的二维数组a的所有元素输出, 要求先按行的顺序输出,然后再以列的顺序输出, 其中输出整型格式用 “%3d”, (测试用数据大小不要超过2位数)。 函数接口定义: void reOut(int (*p)[3]...
  • //利用指针输出二维数组任意行任意列的值 #include&lt;stdio.h&gt; int main() { int array[][4]={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16}; int (p)[4]; p=array; int i,j; scanf("%d,%d",&...
  • c语言二级指针与二维数组

    千次阅读 2019-05-20 15:00:56
    一、二维数组的地址不能赋给二级指针的原因 int arr[][3] = { { 1,2,3 },{ 4,5,6 },{ 7,8,9 } }; int** p = arr; 二、指针遍历二维数组 int* p1 = arr; for (int i = 0; i < sizeof(arr)/sizeof(arr[0][0]); ...
  • 1.二维数组 1.1、二维数组的内存映像 (1)一维数组在内存中是连续分布的多个内存单元组成的,而二维数组在内存中也是连续分布的多个内存单元组成的。 (1)从内存角度来看,一维数组和二维数组没有本质差别。 (2)二维...
  • 二维数组与指针详解

    2018-01-20 15:00:54
    详细讲述了二维数组与指针之间的联系,对于学习C语言,理解指针数组吗,数组指针,数组与指针之间的关系有重要的帮助。仔细学习完该文档,详细你不会再为指针和数据而困惑。
  • 二维数组元素的地址 定义如下二维数组: int a[3][4] = { {0,1,2,3}, {4,5,6,7}, {8,9,10,11} }; a为二维数组名,此数组有3行4列, 共12个元素。但也可这样来理解,数组a由三个元素组成:a[0], a[1], a[2]。...
  • 指针与二维数组指针与指针

    千次阅读 2017-12-15 12:56:00
    问题:3个学生4个科目 分数统计中的二维数组 利用指针 #include float average(float *p,int n) { float *pend=p+n-1; float sum=0; for(;p;p++) { sum+=*p; } return sum/n; }void search
  • 深入浅出理解C语言指针与二维数组.pdf
  • C语言学习笔记——指针指针与二维数组

    千次阅读 多人点赞 2018-11-24 16:58:07
    在C语言中可将一个二维数组看成是由若干一维数组构成的。如: int a[3][4]; 首先,可将二维数组a看成是由a[0],a[1],a[2]三个元素组成的一维数组,a是该一维数组的数组名,代表该一维数组的首地址,即第一个元素a...
  • 指针与维数组 指针移动方式访问数组元素: int a[5], *p; // a存放了数组的首地址 p=a; // 数组首地址赋给p p++; // 向下移动4个字节 指针与数组名都是地址,因此可以混合使用访问数组元素。...
  • 实例浅析C语言中指针与二维数组的应用.pdf
  • 主要介绍了C++中用new创建二维数组指针数组实例代码,非常不错,具有参考借鉴价值,需要的朋友参考下

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 116,564
精华内容 46,625
关键字:

指针与二维数组

友情链接: dac5628.rar