精华内容
下载资源
问答
  • C语言函数调用二维数组,指针问题
    千次阅读
    2021-05-25 04:35:44

    话题:C语言函数调用二维数组,指针问题回答:正如楼下所言 int **p ,定义的p是一个指向int*型的指针int (*p)[1]是一个指向数组的指针 数度为1假如定义成 deal(int **p),传参数时要加类型转换: deal((int**)a);并且使用p时不能用下标,p[2][3]是错误的,因为不知道p指向的int*型的长度,无法编译成*(p+2*1+3)必须自己写成*(p+2*1+3)来调用假如定义成 deal(int (*p)[1])就不一样了,编译器就能知道p是一个指向长度为1的数组的指针那么p[2][3]就能编译成*(p+2*1+3)了总之,C语言是很灵活的,不同的定义方式配上不同的用法,都是能得到正确的结果的不知道这么说楼主明白了没?同样的还有多维数组对多维指针的问题,楼主可以自己类推一下

    参考回答:int **p是指向int*的指针,int(*p)[1] 是指向数组的指针话题:c语言中怎么用二维数组作为函数参数回答:C语言中 指针做函数参数传递二维数组有两种基本方法:1、传递“数组指针”#include void output( int (*pa)[3], int n ) 这个函数只能输出n行3列的二维数组{int i,j;for( i=;i#include void output( int *pa[], int row,int col ) 这个函数更通用,但调用前,要做好准备。{int i,j;for( i=;ilt;row;i++ ){for( j=;jlt;col;j++ )printf("%d ", pa[i][j] );printf("\n");}}void main(){int a[2][3]={{1,2,3},{4,5,6}};int i;int *pa[2];for( i=;ilt;2;i++ )pa[i]=a[i];output(pa, 2, 3);}话题:c语言 二维数组指针函数问题。回答:你定义的二维数组,数组名并不是一个int **类型的指针,而是一个int (* )[N]类型的指针,其中N是二维数组第2维的长度,如果还不懂可以追问我改成这样就可以了:#include话题:C语言问题,请问二维数组的函数参数是怎么传递的?回答:在形参是数组的情况下,只要是数组,无论维数,实际上在调用函数时,传给函数的将是一个数组的首,以及维数等相关也就是说,在函数执行过程中,并不会新开辟内存空间,而是形参实参共用同一段内存空间所以,在这种情况下,函数内部对数组进行修改,其值会返回给实参你的例中调用部分有问题,不能这样shuru(a[1][2])而是shuru(a)因为a[1][2]数组a中的一个元素,而且是越界的而a才是数组名

    参考回答:你好!关于二维数组传参问题,在调用的时候直接传数组指针即可,即:void main(){int a[1][2];shuru(a);shuchu(a);}函数形参有两种写法,可以写成void shuru(int (*array_num)[2]){} 或者void shuru(int array_num[][2]){}函数shuchu() 也是一样,望采纳,如有不明白请追问谢谢!话题:C语言怎么用指针替二维数组回答:设二维数组为typename a[M][N],则指向该数组的指针为typename (*p)[N] = a;这样就可以用p来替二维数组了。

    参考回答:展开全部 #includelt;stdio.hgt;void main(){int i,j;int a[3][3],*p=a[]; 相对于一维数组是一样的,a[]本身就是一个一维数组,不要写成*p=a,写成*p=a[][]也可以for(i=;ilt;3;i++)for(j=;jlt;3;j++)scanf("%d",a[i][j]);printf("%d\n",*(p+5)); 调用就直接加数字,该数字是lt;3*3的就行}话题:C语言怎么以二维数组作为参数传递的问题回答:考虑要把a作为参数传入到print中,那么print函数就要定义一个接收二维数组的参数,那么什么参数能接收二维数组呢。就是print(int (*newbuf)[3])然后newbuf的就是a的,然后newbuf[i][j]来访问每一个元素了有问题继续问哈,写的可

    参考回答:展开全部 考虑要把a作为参数传入到print中,那么print函数就要定义一个接收二维数组的参数,那么什么参数能接收二维数组呢。就是print(int (*newbuf)[3])然后newbuf的就是a的,然后newbuf[i][j]来访问每一个元素了有问题继续问哈,写的可能不太明白话题:c语言问题,用指针为一个二维数组赋值回答:pptr=arr;/p p其实你这样赋值也是可以的,是没有问题的。/p p因为arr是二维数组的数组名,它(arr)本身就这个二维数组的第行的。/p p问题关键不是出现在这里,而是在你程序的while循环语句中/p pwhile(scanf("%f", ptr+i)i!=)/p pi++;/p p你这样写是不对的,首先ptr指向的是一个,所以ptr+i也是一个,所以这里就不能用变址运算符""了。第二个问题是,i 从自加到6,这里面其实有了个数,明显超过了arr数组的长度,这样是不对的。这个循环还有一个问题就是,这本身就是一个不正常的循环(自己想想为什么)/p p下面是我帮你改改的码,希望对你会有帮助。/p p#includestdio.h/p pvoid main()/p p{/p pdouble arr[2][3];/p pdouble *ptr;/p pint i=;/p pptr=*arr; 把数组arr第行第列的赋给ptr,其作用与ptr=arr;相同,/p p 但不建议采用ptr=arr;这样的赋值 /p pprintf("Plese enter 2*3 numbers: \n");/p pfor(i=;i6;i++)/p pscanf("%lf",ptr+i); 注意不要将ptr+i 写成ptr+i 或(ptr+i),否则出错 /p pfor(i=;i6;i++)/p pprintf("%g ",*ptr++);/p pprintf("\n");/p p}/p p/p话题:C语言中指针引用二维数组元素的问题回答:二维数组名a是一个指向指针的指针。也是一个指针数组名,它含3个元素,a[]a[1],a[2]。虽然a存储的是该数组首元素的,但它指向的并不是一个变量,而是一个指针。应为a是一个指向指针的指针,它指向的是和自己存储的相同的指针,即a[],a[]是第一行一维数组的指针,可以指向具体变量。这下明白了吧,*(a+)它不是变量,她是指针,a指向a[],*(a+)就是a[].

    参考回答:呵呵,我也刚学到这个问题,和你分享一下吧,咋看之下,确实像你说的没错,但是这个“[]”运算符和“*()”运算符原来是一个意思的,是不是因为搬到二维数组就混淆了呀,我原来也是有同样的问题的。你看看哪,要是搬回一维数组的话,我们知道a[]与*(a+)是相等的.然后我们再回到二维数组讨论讨论,我认为既然a[][]是二维数组,(a+)怎么看也不可能是二维吧,所以再用“星号”*去取里边的值,换是你,你该怎么取呢?所以呢,它们是相同的应该没错才对,是不是?话题:c语言问题,用指针为一个二维数组赋值回答:pptr=arr;/p p其实你这样赋值也是可以的,是没有问题的。/p p因为arr是二维数组的数组名,它(arr)本身就这个二维数组的第行的。/p p问题关键不是出现在这里,而是在你程序的while循环语句中/p pwhile(scanf("%f", ptr+i)i!=)/p pi++;/p p你这样写是不对的,首先ptr指向的是一个,所以ptr+i也是一个,所以这里就不能用变址运算符""了。第二个问题是,i 从自加到6,这里面其实有了个数,明显超过了arr数组的长度,这样是不对的。这个循环还有一个问题就是,这本身就是一个不正常的循环(自己想想为什么)/p p下面是我帮你改改的码,希望对你会有帮助。/p p#includestdio.h/p pvoid main()/p p{/p pdouble arr[2][3];/p pdouble *ptr;/p pint i=;/p pptr=*arr; 把数组arr第行第列的赋给ptr,其作用与ptr=arr;相同,/p p 但不建议采用ptr=arr;这样的赋值 /p pprintf("Plese enter 2*3 numbers: \n");/p pfor(i=;i6;i++)/p pscanf("%lf",ptr+i); 注意不要将ptr+i 写成ptr+i 或(ptr+i),否则出错 /p pfor(i=;i6;i++)/p pprintf("%g ",*ptr++);/p pprintf("\n");/p p}/p p/p话题:c语言,指向二维数组的指针变量回答:先从存储的角度对二维数组作一个全面的了解。二维数组在内存中的存储,是按照先行后列依次存放的。从内存的角度看,可以这样说,二维数组其实就是一个一维数组,在内存中没有二维的概念。如果把二维数组的每一行看成一个整体,即看成一个数组中的一个元素,那么整个二维数组就是一个一维数组,它以每一行作为它的元素,这个应该很好理解。第一,来详细介绍二维数组与指针的。- 首先定义个二维数组 array[3][4],p 为指向数组的指针。若p=array[],此时p指向的是二维数组第一行的首,则 p+i 将指向array[]数组中的元素array[][i]。由以上所介绍的二维数组在内存中的存储方式可知,对数组中的任一元素array[i][j] ,其指针的形式为:p+i*N+j (N为每一行的长度)。 元素相应的指针表示法为:*(p+i*N+j) ,下标表示法为:p[i*N+j] 。For Example:array[4][3]={{1,2,3},{4,5,6},{,,},{1,11,12}}; int * p=array[]; 数组array有四个元素,分别为array[],array[1],array[2],array[3],每个元素为包含3个元素的一维数组,如array[]的3个元素为 array[][],array[][1],array[][2]。元素array[2][2]对应指针为:array+2*3+2,指针表示法为:*(array+2*3+2) , 下标表示法为:array[2*3+2] 。特别注意:虽然 array[] 与 array 都是数组首,但两者指向的对象不同,这点要非常明确。array[] 是一维数组的名字,它指向的是一维数组array[]的首,所以 *array[]与array[][]为同个值。而 array 是二维数组的名字,它指向的是所属元素的首,其每个元素为一个行数组。它是以‘行’来作为指针移动单位的,如array+i 指向的是第 i 行。对 array 进行 * 运算,得到的是一维数组 array[] 的首,所以 *array 与 array[] 为同个值。如果定义 int* p,p为指int类型的指针,指向int 类型,而不是。故以下作 :p=array[] (正确) ,p=array (错误) 。这点要非常注意。第二,看看如何用数组名作表示其中元素。对二维数组array ,array[] 由 array指向,故*array 与array[] 是相同的,依次类推可得 array[i] 由array+i 指向,*(array+i) 与array[i]是相同的。 因此,对于数组元素 array[i][j] ,用数组名表示为 *(*(array+i)+j) ,指向该元素的指针为 *(array+i)+j 。注意:数组名虽然是,但与指向数组的指针质不同。指针变量可以随时改变其所指向对象,而数组名不可以,一旦被定义,就不能通过赋值使其指向另外一个数组,但是在Ja中则可以。第三,顺便了解一下不太常用的‘行数组指针’。对于二维数组array[4][3],与int* p 。二维数组名array 不能直接赋值给p。原因前面已讲过,两只的对象质不同。 在C语言中,可以通过定义一个行数组指针,使得这个指针与二维数组名具有同样的质,实现它们之间可以直接赋值。行数组指针定义如下:int (*p)[3]; 它表示,数组 *p 具有三个int类型元素,分别为 (*p)[] , (*p)[1] , (*p)[2] ,即 p指向的是具有三个int类型的一维数组,也就是说,p为行指针。此时,以下运算 p=array 是正确的。第四,二维数组作为函数参数。二维数组作为函数参数一般有两种方式:(1) void func(int **array){} (2) void func(int array[ ][N]) 注意第二种方式一定要指明二维数组的列数 当二维数组名作为函数实参时,对应的形参必须是一个行指针变量。和一维数组一样,数组名传送给变量的是一个值,因此,对应的形参也必须是一个类型相同的指针变量,在函数中引用的将是主函数中的数组元素,系统只为形参开辟一个存放的存储单元,而不可能在调用函数时为形参开辟一系列存放数组的存储单元。int main() double a[3][4]; …… fun(a); …… fun(double (*a)[n]) ……

    参考回答:楼主你好:二维数组的指针不难理解。请参看我的帖:: zhidao.baidu./question/126624 是关于指针的很通俗易懂的解释!有不明白的,我就可以了。:24526倒数第四行*(*(a+2)+2)就等价于你写的*(*board+i))其实就是*board[i]。*board就相当于board[][]的,也就是board[][]

    更多相关内容
  • (2)、第二种是用一维数组来表示二维数组,从显示的元素地址可以看出,二维数组和一维数组表示的二维数组在内存中的储存方式其实是一样的,不过使用二维数组看起来要简单些,只要不用进行地址转换。 (3)、第三...
  • 在php中数组排序一直是一个老生常谈的问题,下面我们集中讲一下关于在php中一维数组与二维数组排序的实现程序,相信大家有一定的参考借鉴价值. 功能:对数组进行重新排序. 说明:冒泡排序 (一维数组)(二维数组某个...
  • 常用的系统函数有sort、asort、arsort、ksort、krsort等等,这里我主要对二维数组的排序,两种方法: 一、用PHP自带array_multisort函数排序 复制代码 代码如下:<?php  $data = array(); $da
  • 主要介绍了C++指针数组、数组指针、数组名及二维数组技巧汇总,对于深入理解C++数组与指针来说非常重要,需要的朋友可以参考下
  • 1. 二维数组常用创建方法 静态二维数组 ① 确定行和列 a. 不确定元素 int a[2][2]; b. 部分元素确定 int a[2][3] ={1,2,3,4}; c. 确定元素 int a1[2][2] = {{1,2,}{3,4}};//标准的二维数组初始化方式 //在写明列号...

    1. 二维数组常用创建方法

    静态二维数组

    ① 确定行和列

    a. 不确定元素

    int a[2][2];
    

    b. 部分元素确定

    int a[2][3] ={1,2,3,4};
    

    c. 确定元素

    int a1[2][2] = {{1,2,}{3,4}};//标准的二维数组初始化方式
    //在写明列号时{1,2,3,4}也可
    

    ②不指明行,指明列

    //a. 经典写法:
    int array[][3];
    
    //b. 利用指针:
    int (*array)[3];
    

    动态二维数组

    ① 利用指针创建

        //c++使用new申请空间,
        //c使用 int **array = (int **)malloc(rows*sizeof(int *))
        int** a2 = new int*[rows]; //a2[rows][columns]
        //此时一个指针指向一个指针数组
        for(int i=0;i<rows;i++)
            a2[i] = new int[columns];
            //指针数组a2每一个(指针)元素指向一个数组
        for(int i=0;i<rows;i++){
        	for(int j=0;j<columns;j++){
        		a2[i][j]= i * columns + j;//初始化数组元素
        		cout << a2[i][j];
        	}
        }
        //释放空间
        for(int i=0;i<rows;i++)
            delete []a2[i];
            //先撤销指针元素指向的数组
        delete []a2;
        //再撤销指针数组
    

    创建2*3的数组并初始化:

    #include <iostream>
    using namespace std;
    
    int main(int argc, char** argv) {
    	int rows,columns;
    	cin >> rows >> columns;
    	//申请空间
        int** a2 = new int*[rows];
        //此时一个指针指向一个指针数组
        for(int i=0;i<rows;i++)
            a2[i] = new int[columns];
            //指针数组a2每一个(指针)元素指向一个数组
        for(int i=0;i<rows;i++){
        	for(int j=0;j<columns;j++){
        		a2[i][j]= i * columns + j;//初始化数组元素
        		cout << a2[i][j] << " ";
        	}
        	cout << endl;
        }
        //释放空间
        for(int i=0;i<rows;i++)
            delete []a2[i];
            //先撤销指针元素指向的数组
        delete []a2;
        //再撤销指针数组
    	return 0;
    }
    

    运行结果
    创建2*3的数组并初始化

    ② 利用vetor创建二维数组

    参考:vetor创建二维数组

    二维数组创建完毕 接下来看作为**“返回值”以及函数形式参数**的情况

    2. 二维数组作为函数返回值类型

    C++规定:数组的空间是在运行前分配的。
    

    因此二维数组长度理论上为定值,是不能修改的,因此无法直接将二维数组作为返回值类型,但可以使用结构体或者指针来完成相似的功能。

    结构体

    思路:定义一个结构体,结构体里面放一个数组,但这样做的缺陷数组大小需要固定,没办法根据输入动态产生一个指定大小的结构体。

    struct dis{
    	int num[rows][columns];//rows,columns均需要先给定
    };
    

    指针

    ① 动态创建存放矩阵相乘结果的二维数组 d

    a. 开辟大小为 m 的 int 型指针数组空间

    int **d = (int **)malloc(m*sizeof(int *));
    

    b. 再为每一个指针元素开辟大小为 n的 int 型数组空间

    for ( int i = 0;i < m;i++){
    		d[i] = (int *)malloc(p*sizeof(int)); 
    	}
    

    c. 用完释放二维数组空间

    //释放空间
        for(int i=0;i<m;i++)
            delete []d[i];
            //先撤销指针元素指向的数组
        delete []d;
        //再撤销指针数组
    

    ② 给二维数组赋值

    ③ return d;

    完整代码:

    /*
    矩阵相乘 A[m][n]*B[n][p] 输出result[m][p]
    */ 
    #include <iostream>
    #include <stdlib.h>
    using namespace std;
    
    int **determinantMutiply(int M,int N,int P){
        
    	cout << "请输入矩阵A的各个元素:" << endl;
    	int A[M][N] = {0};
    	for(int i = 0; i < M;i++){
    		for (int j = 0;j < N;j++){
    			cout << "A[" << i << "][" << j << "]=";
    			cin >> A[i][j];
    		}
    	}
    	
    	cout << "请输入矩阵B的各个元素:" << endl;
    	int B[N][P] = {0};
    	for(int i = 0; i < N;i++){
    		for (int j = 0;j < P;j++){
    			cout << "B[" << i << "][" << j << "]=";
    			cin >> B[i][j];
    		}
    	}
    	
    	int **d = (int **)malloc(M*sizeof(int *));
    	for ( int i = 0;i < M;i++){
    		d[i] = (int *)malloc(P*sizeof(int)); 
    	}
    	int C[M][P];
    	for (int i = 0;i < M;i++){
    		for (int j = 0;j < P;j++){
    			C[i][j] = 0;
    			for(int k = 0; k < N;k++)
    				C[i][j] += A[i][k] * B[k][j]; 
    				d[i][j] =  C[i][j];
    		}
    	}
    	return d;
    	//释放空间
        for(int i=0;i<M;i++)
            delete []d[i];
            //先撤销指针元素指向的数组
        delete []d;
        //再撤销指针数组
    } 
    int main(int argc, char** argv) {
    	int M,N,P;
    	cout << "请输入矩阵A的维数(M,N):" << endl ;
    	cout << "M = ";
    	cin >> M;
    	cout << "N = ";
    	cin >> N;
    	cout << "请输入矩阵B的维数(N,P):" << endl ;
    	cout << "P = ";
    	cin >> P;
    
    	int **result = (int **)malloc(M * sizeof(int *));
    	for (int i = 0; i < M; i++)
    	{
    	    result[i] = (int *)malloc(P * sizeof(int));
    	}
    	result = determinantMutiply(M,N,P);
    	cout << "A * B的结果是" << endl;
    	for(int i = 0;i < M;i++){
    		for (int j = 0;j < P;j++){
    			cout << result[i][j] << " ";
    		}
    		cout << endl;
    	}	
    	return 0;
    }
    

    运行结果:
    矩阵相乘
    不熟悉指针可以看这个:用的vectorC++ 函数返回二维数组

    3.二维数组作为形式参数

    int **array;
    int n;
    cin >> n;
    array = new int *[n];
    for(i = 0; i <n; i++)
        array[i] = new int[n];
    函数声明:void fuc(int **a);
    函数调用:fuc(array);
    
    在函数fuc中, a是指针的指针。
    使用array[i * j + j]形式来访问数组中元素。
    //这是由传统数组与指针数组分配空间不同的方式而决定的
    

    两种内存空间详细说明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 的分布是一维线性的,整个数组...

    在概念上是二维的,有行和列,但在内存中所有的数组元素都是连续排列的,它们之间没有 “缝隙”。以下面的二维数组 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)结论,可以很容易推出以下的等价关系:

    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 个字节的内存。

    二级指针

    使用二级指针初始化一级指针

     

    #include <stdio.h>
    #include <string.h>
    #include <stdlib.h>
    enum
    {
        Success,NameErr,SexErr,StrNumErr,ScoreErr
    };
    typedef struct stu
    {
        char *name;
        char *sex;
        char *strNum;
        float *score;
    }STU;
    int init(STU ** p)
    {
        *p = (STU *)malloc(sizeof(STU));//*p就是ps,申请一块空间里面存放4个不同类型的指针,将首地址赋值给ps
        //初始化一级指针,使这4个不同类型的指针都有所指向
        (*p)->name = (char *)malloc(sizeof(100));
        if((*p)->name == NULL)
            return NameErr;
        (*p)->sex = (char *)malloc(sizeof(char));
        if((*p)->sex == NULL)
            return SexErr;
        (*p)->strNum = (char *)malloc(sizeof(30));
        if((*p)->strNum == NULL)
            return StrNumErr;
        (*p)->score = (float *)malloc(sizeof(float));
        if((*p)->score == NULL)
            return ScoreErr;
        return Success;
    }
    int main(void)
    {
        STU * ps = NULL;
    
        int ret = init(&ps);
        if(ret != Success)
            return -1;
        strcpy(ps->name,"wahaha");
        *(ps->sex) = 'x';
        strcpy(ps->strNum,"语文");
        *(ps->score) = 66.5;
    
        printf("姓名:%s\n性别:%c\n科目:%s\n分数:%.2f\n",ps->name,*(ps->sex),ps->strNum,*(ps->score));
        return 0;
    }

    展开全文
  • C语言二维数组指针(指向二维数组的指针)详解

    万次阅读 多人点赞 2020-05-27 17:43:22
    以下面的二维数组 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语言指针数组(数组每个元素都是指针)详解
    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 个字节的内存。

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

    展开全文
  • C/C++ 定义并赋值二维数组

    千次阅读 2021-05-22 13:34:02
    本文转载的是CSDN大大MoreWindows的博客在C/C++中动态分配二维数组可以先申请一维的指针数组,然后该数组中的每个指针再申请数组,这样就相当于二维数组了,但是这种方法会导致每行可能不相邻,从而访问效率比较低。...
  • php中怎么将二维数组转为一维数组

    千次阅读 2021-03-23 14:29:34
    php中将二维数组转为一维数组的方法是:可以使用array_column()函数实现。该函数返回一个数组,数组的值为输入数组中某个单一列的值。具体方法如:【array_column($records, 'first_name')】。相关函数介绍:(推荐...
  • C语言数组——二维数组

    万次阅读 多人点赞 2020-02-07 14:58:35
    C语言目录 C/C++学习资源(百度云盘链接) 计算机二级资料(过级专用) C语言学习路线(从入门到实战) 编写C语言程序的7个步骤和编程机制 C语言基础-第一个C程序 C语言基础-简单程序分析 ...二维数组 前面介绍了...
  • 二维数组及遍历

    万次阅读 多人点赞 2019-09-12 17:41:23
    二维数组及遍历 概念 初始化方式详解 遍历 我在前面的博文详细过一维数组的概念初始化方式及遍历,今天这篇博文,可以看过前面博文的会很容易接受,前置博文,请直接点击链接跳转。 什么是二维数组二维数组和...
  • 但是自己突然想测试一下,用new创建的二维数组是真的二维数组吗? 首先我们真的 C++可以直接定义二维数组 只要row和col都知道,就可以确定二维数组大小。 int num[10][10]; 明确了row和col,就不太容易越界了。...
  • 区别二维数组中的 aa[0]

    千次阅读 2019-10-19 16:54:37
    区别二维数组中的 aa[0] 文章目录区别二维数组中的 aa[0]起步正文参考 起步 在一个二维数组 a[2][3] 中,aa[0] 拥有相同的地址,但它们各自存在的意义却不同。 正文 现在,我们创建一个二维数组,再...
  • 二维数组是一页纸 三维数组是一本书 四维数组是书架 五维数组是图书室2201(好几个书架) 六维数组是图书馆某一层,2楼/3楼,好几个图书室 七维数组是整个图书馆 第N维数组是宇宙...................
  • 深入理解一维数组与二维数组

    千次阅读 多人点赞 2021-10-08 10:49:50
    通过一些例子,加深一维数组和二维数组的理解
  • C语言 二维数组定义和使用 - C语言零基础入门教程

    千次阅读 多人点赞 2021-08-22 15:13:10
    目录 一.二维数组简介 二.定义二维数组并初始化 1.定义二维数组 2.初始化二维数组 ...三.访问二维数组 ...而二维数组和一维数组类似,简单理解就是:二维数组由多个一维数组构成,语法如下: type arrayName
  • 维数组元素a[i]的地址可以写成表达式&a[i]或a+i,&a[i]是用下标形式表示的地址,a+i是用指针形式表示的地址,二者结果相同。元素a[i]的地址等于数组首地址向后偏移若干字节,偏移的字节数等于a[i]与首地址...
  • 二维数组映射到一维数组上

    千次阅读 2021-04-18 16:16:23
    C语言使用multidimensional array的行顺序要用单维数组来模拟这个,可以将行索引乘以宽度,然后添加列索引:int array[width * height]; int SetElement(int row, int col, int value) { array[width * row + col] =...
  • C/C++函数传递二维数组

    千次阅读 2020-11-20 10:38:31
    2.根据数组的存储原理把二位数组当作一维数组来操作(降维处理) 函数参数传递二维数组的问题 将二维数组当作参数的时候,必须指明所有维数大小或者省略第一维的,但是不能省略第二维或者更高维的大小,这是由...
  • C语言指针(二维数组

    千次阅读 2021-05-07 20:58:57
    (1)从内存角度看,一维数组和二维数组没有本质差别。 (2)二维数组int a[2][5]和一维数组int b[10]其实没有任何本质差别。我们可以把两者的同一单元的对应关系写下来。 a[0][0] a[0][1] a[0][4] a[1][0] a[1][1] ...
  • 二级C:二维数组

    千次阅读 2021-11-08 20:49:24
    二维数组 一、定义 ①数组两个中括号[][],第一个可有可无,第二个必须有,里面的内容为常量表达式,也就是不能改变的。 当数组中每个元素带有两个下标时,称这样的数组为二维数组。 在C语言中,二维数组的定义语句...
  • 今天在做游戏的时候,由于地图是用二维数组实现的,而且有点大,想用一些函数操作二维数组,遇到这个问题,花了不少功夫,大家一起看下吧 第一,参数为二维数组的函数声明方式 我就直接举例说明了 void addBase...
  • 二维数组中索引的和

    千次阅读 2020-12-21 14:55:29
    包括下面@seberg评论后的OP代码,OP的方法最快:def sliced_sum_op(a, b, c) :d = np.empty(a.shape[0])for i in xrange(a.shape[0]):d[i] = np.sum(a[i, b[i]:c[i]])return d您仍然可以用np.cumsum实现,...
  • C++二维数组的定义及理解

    万次阅读 多人点赞 2020-11-27 17:26:28
    #二维数组的定义方式 #二维数组结构的含义与理解 前言 一维数组对于存储和处理一组数据很有用,但是有时候,很有必要使用多维数组。 例如,在统计学生成绩的程序中,教师可以将一个学生的所有科目考试分数记录在一个...
  • Java - 将二维数组转化为一维数组

    千次阅读 2021-09-01 17:55:46
    1. 为了偷懒所以我写了一个随机生成二维数组的函数 /* * 自动创建随机为100以内的二维数组: int nums[x][y] * */ public static int[][] CreatedDemArray(int x,int y){ int nums[][]=new int[x][y]; for...
  • 二维数组的冒泡排序(C语言篇)

    万次阅读 多人点赞 2019-10-27 12:06:21
    二维数组的冒牌排序前,让我们再简单的过一遍熟悉的不能再熟悉的一维数组的冒泡排序: 1、一维数组冒泡 1.在这里我自己总结了一个冒泡小公式(基本上C语言的冒泡排序都可以用这个公式完成): int a[n]; //...
  • 二维数组的length如何理解

    千次阅读 2021-04-06 10:11:24
    1. 二维数组的length属性与一维数组不同,主要区别如下: 一维数组表示数组的长度; 在二维数组中:数组名.length指示数组的行数; 数组名[行下标] .length指示该行中的元素个数。
  • 而对于数组来说, 就是一组类型相同的箱子中,一组苹果箱子, 可以放入不同的苹果. 一维数组空间: 变量被声明后, 我们操作编译器, 我们的C源文件进行编译, C在编译的时候 就会给我们的变量开辟相应的空间, 而
  • C语言二维数组的四种遍历方式

    千次阅读 2021-05-12 21:23:38
    二维数组的四种遍历方式: a[i][j] *(a[i]+j) *(*(a+i)+j) *(&a[0][0]+i*n+j) 1.a[i][j] :这种方法是最基本的方式 2.*(a[i]+j) :(a[i]+j)是下标为(i,j.../*Function:二维数组的四种遍历方式:a[i][j],*(a[...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 201,042
精华内容 80,416
关键字:

对二维数组a来说