指向二维数组的指针_百度知道
色情、暴力
我们会通过消息、邮箱等方式尽快将举报结果通知您。
指向二维数组的指针
nt a[5][10]={1,2};&p[9]&&cout&&p[0]&&int (*p)[10]=a;cout&&p&&cout&p是指向二维数组a的指针
int(*p)[10]定义了一个指向二维数组的指针p，赋给它10个长度。然后把a数组的值赋给(*p)[10]，注意，这里是a数组是5行10列的，放入（*p）[10]是把a[0][0]，a[0][1]，a[0][2]，a[0][3]，a[0][4]，a[0][5]，a[0][6]，a[0][7]，a[0][8]，a[0][9]放入(*p)[0]中，同理，将a[1][0...9]放入(*p)[1]。最后（*p）[10]中的值只有五行被初始化为a数组的值了。在本例中，p和p[0]是同一个意思，就是数组a的起始地址，等价于cout&&a&&endl，但是他们有区别，p指向的是整个数组的首地址，而p[0]则指向a的首行首地址（继续往下看...）。p[9]则值内存为p数组分配的(*p)[9]的地址。如果你仔细验证程序的输出结果，你就会发现：#include&stdio.h&#include &iostream&using std::using std::using std::void main(){int a[5][10]={1,2};int (*p)[10]=a;cout&&p&&cout&&p[0]&&cout&&p[9]&&}输出结果为(不同机器结果不同)：0012FEB80012FEB8如果你验证它们这些地址存储的值，你会发现：#include&stdio.h&#include &iostream&using std::using std::using std::void main(){int a[5][10]={1,2};int (*p)[10]=a;cout&&*p&&cout&&(*p)[0]&&cout&&(*p)[9]&&}输出结果为：0012FEB810这是p和p[0]的区别就体现出来了。因为*p并不是取首元素的值，它这时才相当于p[0]。那如何通过p取得首元素的值呢，很显然，应该再加一个*操作符，如下：cout&&**p&&这时输出结果自然就会和(*p)[0]一样是1了。
采纳率：77%
p[0]指向数组a的起始地址p[9]野指针
为您推荐：
其他类似问题
二维数组的相关知识
换一换
回答问题，赢新手礼包博客访问： 3919167
博文数量： 544
博客积分： 13065
博客等级： 上将
技术积分： 9067
注册时间：
IT168企业级官微
微信号：IT168qiye
系统架构师大会
微信号：SACC2013
分类： C/C++
对于“”，这里的“1”是啥？
如果，则“1”实际是，也就是指向的类型大小；
如果，则“1”实际是，仍然是指向的类型大小；
如果，则“1”是，而“”中的“1”则为，依然是或指向类型的大小。
1.1.&双指针
指向一个指针的指针。
1.2.&指针数组
由指针值组成的数组，也就是说数组的每个元素值的数据类型均为指针类型，如：int*&p[2];
1.3.&数组指针
指向一个数组的指针。
列数和行数都不确定，而且每行可以列数不等。
int*&p2[3];
共3行，每行多少列不确定，而且每行可以列数不等。
int&(*p3)[3];
共3列，多少行不确定。
int*&p2[3];
int&(*p3)[3];
int&p4[2][3];
int&p5[3];
p3&=&&p5;&//&p5的列数必须和p3的列数相同
p1&=&p2;&//&两者列数均不确定，可兼容
“列数相等”或“列数不确定”是兼容的提前条件，如上述的p3、p4和p5三者的列数均相同。
4.&为何列数须相等？
指针支持加减操作，比如：
int&m[3][3];
int&(*pm)[3]&=&m&+&1;
上述第二行的m是指二维数组“int&m[3][3];”在内存中的首地址，如：0x7fff。而这个“1”是指这个二维数组一行的大小，也就是“int&m[3];”的大小。因此，pm的值为：0x7fff&+&12&=&0x7fffd5afd94c。
如果列数不相等，则加减操作无法进行，因此需要“列数相等”。假设：
int**&b2&=&b1&+&1;
上述中的“1”实际是多少？这个就要看b1的类型是什么？在这里，b1是一个双指针，也就是指向指针的指针。本质上就是一个指针，因此在32位平台上它的值是4，在64位平台上它的值是8。
如何来初始化双指针、指针数组和数组指针？直接看下面的代码：
int&main()
&&&&&&&&size_t&i;&//&行
&&&&&&&&size_t&j;&//&列
&&&&&&&&int**&p1;&&&&&//&行数和列数，均不固定
&&&&&&&&int*&p2[3];&&&//&行数固定为3，列数不固定
&&&&&&&&int&(*p3)[3];&//&列数固定为3，行数不固定
&&&&&&&&size_t&num_rows_p1&=&3;&//&行数不固定，可运行时设定
&&&&&&&&p1&=&new&int*[num_rows_p1];
&&&&&&&&for&(i=0;&i<num_rows_p1;&++i)
&&&&&&&&&&&&&&&&size_t&num_cols_p1&=&i&+&1;&//&列数不固定，可运行时设定
&&&&&&&&&&&&&&&&p1[i]&=&new&int[num_cols_p1];
&&&&&&&&&&&&&&&&for&(j=0;&j<num_cols_p1;&++j)
&&&&&&&&&&&&&&&&&&&&&&&&p1[i][j]&=&i;
&&&&&&&&printf("p1[2][1]=%d\n",&p1[2][1]);
&&&&&&&&printf("p1[2][2]=%d\n",&p1[2][2]);
&&&&&&&&const&size_t&num_rows_p2&=&sizeof(p2)/sizeof(p2[0]);&//&行数固定，不可运行时设定
&&&&&&&&for&(i=0;&i<num_rows_p2;&++i)
&&&&&&&&&&&&&&&&size_t&num_cols_p2&=&i&+&1;&//&列数不固定，可运行时设定
&&&&&&&&&&&&&&&&p2[i]&=&new&int[num_cols_p2];
&&&&&&&&&&&&&&&&for&(j=0;&j<num_cols_p2;&++j)
&&&&&&&&&&&&&&&&&&&&&&&&p2[i][j]&=&i;
&&&&&&&&printf("p2[2][1]=%d\n",&p2[2][1]);
&&&&&&&&printf("p2[2][2]=%d\n",&p2[2][2]);
&&&&&&&&size_t&num_rows_p3&=&5;&//&行数不固定，可运行时设定
&&&&&&&&const&size_t&num_cols_p3&=&3;&//&列数固定，不可运行时设定
&&&&&&&&p3&=&new&int[num_rows_p3][num_cols_p3];
&&&&&&&&for&(i=0;&i<num_rows_p3;&++i)
&&&&&&&&&&&&&&&&for&(j=0;&j<num_cols_p3;&++j)
&&&&&&&&&&&&&&&&&&&&&&&&p3[i][j]&=&i;
&&&&&&&&printf("p3[2][1]=%d\n",&p3[2][1]);
&&&&&&&&printf("p3[2][2]=%d\n",&p3[2][2]);
&&&&&&&&return&0;
下面这个表格，在内存中即可为“int**&p1;”，也可以为“int*&p2[3];”，还可以为“int&(*p3)[3];”
如下来操作它：
int&main()
&&&&&&&&int&m[3][3]&=&{&{1,2,3},&{4,5,6},&{7,8,9}&};
&&&&&&&&int**&p1;
&&&&&&&&int*&p2[3];
&&&&&&&&int&(*p3)[3];
&&&&&&&&p1&=&new&int&*[3];
&&&&&&&&p1[0]&=&m[0];&//&列数不固定
&&&&&&&&p1[1]&=&m[1];&//&列数不固定
&&&&&&&&p1[2]&=&m[2];&//&列数不固定
&&&&&&&&printf("p1[1][2]=%d\n",&p1[1][2]);
&&&&&&&&p2[0]&=&m[0];&//&列数不固定
&&&&&&&&p2[1]&=&m[1];&//&列数不固定
&&&&&&&&p2[2]&=&m[2];&//&列数不固定
&&&&&&&&printf("p2[1][2]=%d\n",&p2[1][2]);
&&&&&&&&p3&=&m;&//&列数固定
&&&&&&&&printf("p3[1][2]=%d\n",&p3[1][2]);
&&&&&&&&delete&[]p1;
&&&&&&&&return&0;
实际上，还可以当作一维数组，但仍然可以使用“int**&p1;”、“int*&p2[3];”和int&(*p3)[3];”来操作，看下面的代码：
int&main()
&&&&&&&&int&n[9]&=&{&1,2,3,&4,5,6,&7,8,9&};
&&&&&&&&int**&p1;
&&&&&&&&int*&p2[3];
&&&&&&&&int&(*p3)[3];
&&&&&&&&p1&=&new&int&*[3];
&&&&&&&&p1[0]&=&n;
&&&&&&&&p1[1]&=&n&+&3;
&&&&&&&&p1[2]&=&n&+&6;
&&&&&&&&printf("p1[1][2]=%d\n",&p1[1][2]);
&&&&&&&&p2[0]&=&n;
&&&&&&&&p2[1]&=&n&+&3;
&&&&&&&&p2[2]&=&n&+&6;
&&&&&&&&printf("p2[1][2]=%d\n",&p2[1][2]);
&&&&&&&&p3&=&(int&(*)[3])n;&//&这里也可改成：p3&=&(int&(*)[3])&n;
&&&&&&&&printf("p3[1][2]=%d\n",&p3[1][2]);
&&&&&&&&delete&[]p1;
&&&&&&&&return&0;
二维数组同样也可以当一维数组使用，如：
int&main()
&&&&&&&&int&m[3][3]&=&{&{1,2,3},&{4,5,6},&{7,8,9}&};
&&&&&&&&int&*p&=&(int*)m;&//&这里同样也可以改成：int&*p&=&(int*)&m;
&&&&&&&&printf("p[1]=%d,&p[3]=%d,&p[6]=%d\n",&p[1],&p[3],&p[6]);
&&&&&&&&return&0;
int&m[3];&int*&p1;&int**&p2;&int*&p3[3];&int&(*p4][3]);的本质是相同的，都表示一块内存，只所以有区分，是为了编译器能够按照不同的方式去访问这块内存。更通俗点说，它们都是对内存访问的协议。
从前面的例子不难看出，对于双指针“int**&p1;”在使用之前，总是会先做“new&int*[]”操作。如果让p1直接指向数组首地址是否可以了？
答案是不行的，假设有如下的代码：
int&m[9]&=&{&0x1,0x2,0x3,0x4,0x5,0x6,0x7,0x8,0x9&};
int**&pp&=&(int**)m;
pp[0]、pp[1]、pp[2]。。。是什么？用下面这段代码来观察：
int&main()
&&&&&&&&int**&pp&=&NULL;
&&&&&&&&int&m[9]&=&{&0x1,0x2,0x3,0x4,0x5,0x6,0x7,0x8,0x9&};
&&&&&&&&pp&=&(int**)m;
&&&&&&&&printf("pp[0]=%p,&pp[1]=%p,&pp[2]=%p,&pp[3]=%p\n",&pp[0],&pp[1],&pp[2],&pp[3]);
&&&&&&&&return&0;
上面这段代码中的数组元素值特意使用了16进制，以便更好的观察，它的实际输出和机器的字节序，以及位数相关，在x86输出为：
pp[0]=0x1,&pp[1]=0x2,&pp[2]=0x3,&pp[3]=0x4
在x86_64上输出为：
pp[0]=0x,&pp[1]=0x,&pp[2]=0x,&pp[3]=0x
不要被双指针“**”迷惑了，可对比下“int*&p;”
int&main()
&&&&&&&&int*&p&=&NULL;
&&&&&&&&int**&pp&=&NULL;
&&&&&&&&int&m[9]&=&{&0x1,0x2,0x3,0x4,0x5,0x6,0x7,0x8,0x9&};
&&&&&&&&pp&=&(int**)m;
&&&&&&&&printf("pp[0]=%p,&pp[1]=%p,&pp[2]=%p,&pp[3]=%p\n",&pp[0],&pp[1],&pp[2],&pp[3]);
&&&&&&&&p&=&m;
&&&&&&&&printf("p[0]=%d,&p[1]=%d,&p[2]=%d,&p[3]=%d\n",&p[0],&p[1],&p[2],&p[3]);
&&&&&&&&return&0;
因为pp是双指针类型，因此它不能直接指向数组内存。
假设有一指针：int*&p;，它的地址为x，则p[N]和*(p+N)都是取地址为“x+sizeof(int)”的内存数据；如果是“int**&”，设地址为y，则pp[N]和*(pp+N)是取地址为“y+sizeof(int*)”的内存数据。
8.1.&数组、指针和双指针关系图
8.2.&数组和双指针关系图
8.3.&演示代码
int&main()
&&&&&&&&int&m[]&=&{&1,2,3,4,5,6,7,8,9&};
&&&&&&&&int*&p&=&m;
&&&&&&&&int**&pp&=&&p;
&&&&&&&&printf("sizeof(p)=%d\n",&sizeof(p));
&&&&&&&&printf("sizeof(*p)=%d\n",&sizeof(*p));
&&&&&&&&printf("m=%p\n",&m);
&&&&&&&&printf("&p=%p\n",&&p);
&&&&&&&&printf("*p=%lx\n",&*pp);
&&&&&&&&printf("**p=%d\n",&**pp);&//&这实际是“*((*pp)+0))”而不是“*(*(pp+0))”
&&&&&&&&printf("*((*p)+0)=%d\n",&*((*pp)+0));
&&&&&&&&printf("pp=%p\n",&pp);
&&&&&&&&printf("pp+1=%p\n",&pp+1);
&&&&&&&&//&不要将“pp[0][1]”理解成：**(pp+0+1)，
&&&&&&&&//&这里的1实际是sizeof(*pp)，也就是sizeof(int*)，
&&&&&&&&//&而pp是p的地址，注意不是m的地址
&&&&&&&&printf("&m[1]=%p\n",&&m[1]);
&&&&&&&&printf("&pp[0][1]=%p\n",&&pp[0][1]);&//&p[0]也就是*(p+0)
&&&&&&&&printf("pp[0][1]=%d\n",&pp[0][1]);&//&p[0][1]也就是*((*(pp+0))+1))
&&&&&&&&printf("*((*(pp+0))+1)=%d\n",&*((*(pp+0))+1));
&&&&&&&&printf("*((*pp)+1)=%d\n",&*((*pp)+1));&//&正确，*pp是m的地址
&&&&&&&&printf("**(pp+1)=%d\n",&**(pp+1));&//&越界了，因为pp的值是p的地址，不是m的地址
&&&&&&&&return&0;
9.&相关参考
《进一步理解指针：一维数组和二维数组转换》：
《常见指针定义解读》
阅读(2439) | 评论(0) | 转发(2) |
相关热门文章
给主人留下些什么吧！~~
请登录后评论。C语言指向多维数组的指针_C语言中文网
&&/&&&&/&&
本小节以二维数组为例介绍多维数组的指针变量。
多维数组的地址
设有整型二维数组a[3][4]如下：
0 & 1 & 2 & 3
4 & 5 & 6 & 7
8 & 9 &10 &11&
它的定义为：
& & int a[3][4]={{0,1,2,3},{4,5,6,7},{8,9,10,11}}
设数组a的首地址为1000，各下标变量的首地址及其值如图所示。
前面介绍过，C语言允许把一个二维数组分解为多个一维数组来处理。因此数组a可分解为三个一维数组，即a[0]、a[1]、a[2]。每一个一维数组又含有四个元素。
例如a[0]数组，含有a[0][0]，a[0][1]，a[0][2]，a[0][3]四个元素。
数组及数组元素的地址表示如下：从二维数组的角度来看，a是二维数组名，a代表整个二维数组的首地址，也是二维数组0行的首地址，等于1000。a+1代表第一行的首地址，等于1008。如图：
a[0]是第一个一维数组的数组名和首地址，因此也为1000。*(a+0)或*a是与a[0]等效的， 它表示一维数组a[0]0 号元素的首地址，也为1000。&a[0][0]是二维数组a的0行0列元素首地址，同样是1000。因此，a，a[0]，*(a+0)，*a，&a[0][0]是相等的。
同理，a+1是二维数组1行的首地址，等于1008。a[1]是第二个一维数组的数组名和首地址，因此也为1008。&a[1][0]是二维数组a的1行0列元素地址，也是1008。因此a+1,a[1],*(a+1),&a[1][0]是等同的。
由此可得出：a+i，a[i]，*(a+i)，&a[i][0]是等同的。
此外，&a[i]和a[i]也是等同的。因为在二维数组中不能把&a[i]理解为元素a[i]的地址，不存在元素a[i]。C语言规定，它是一种地址计算方法，表示数组a第i行首地址。由此，我们得出：a[i]，&a[i]，*(a+i)和a+i也都是等同的。
另外，a[0]也可以看成是a[0]+0，是一维数组a[0]的0号元素的首地址，而a[0]+1则是a[0]的1号元素首地址，由此可得出a[i]+j则是一维数组a[i]的j号元素首地址，它等于&a[i][j]。
由a[i]=*(a+i)得a[i]+j=*(a+i)+j。由于*(a+i)+j是二维数组a的i行j列元素的首地址，所以，该元素的值等于*(*(a+i)+j)。
【例10-22】
int a[3][4]={0,1,2,3,4,5,6,7,8,9,10,11};
printf(&%d,&,a);
printf(&%d,&,*a);
printf(&%d,&,a[0]);
printf(&%d,&,&a[0]);
printf(&%d\n&,&a[0][0]);
printf(&%d,&,a+1);
printf(&%d,&,*(a+1));
printf(&%d,&,a[1]);
printf(&%d,&,&a[1]);
printf(&%d\n&,&a[1][0]);
printf(&%d,&,a+2);
printf(&%d,&,*(a+2));
printf(&%d,&,a[2]);
printf(&%d,&,&a[2]);
printf(&%d\n&,&a[2][0]);
printf(&%d,&,a[1]+1);
printf(&%d\n&,*(a+1)+1);
printf(&%d,%d\n&,*(a[1]+1),*(*(a+1)+1));
指向多维数组的指针变量
把二维数组a分解为一维数组a[0]、a[1]、a[2]之后，设p为指向二维数组的指针变量。可定义为：
& & int (*p)[4]
它表示p是一个指针变量，它指向包含4个元素的一维数组。若指向第一个一维数组a[0]，其值等于a,a[0]，或&a[0][0]等。而p+i则指向一维数组a[i]。从前面的分析可得出*(p+i)+j是二维数组i行j 列的元素的地址，而*(*(p+i)+j)则是i行j列元素的值。
二维数组指针变量说明的一般形式为：
& & 类型说明符& (*指针变量名)[长度]
其中&类型说明符&为所指数组的数据类型。&*&表示其后的变量是指针类型。&长度&表示二维数组分解为多个一维数组时，一维数组的长度，也就是二维数组的列数。应注意&（*指针变量名）&两边的括号不可少，如缺少括号则表示是指针数组（本章后面介绍），意义就完全不同了。
【例10-23】
int a[3][4]={0,1,2,3,4,5,6,7,8,9,10,11};
int(*p)[4];
for(i=0;i&3;i++){
for(j=0;j&4;j++) printf(&%2d
&,*(*(p+i)+j));
printf(&\n&);
编程帮，一个分享编程知识的公众号。跟着一起学习，每天都有进步。
通俗易懂，深入浅出，一篇文章只讲一个知识点。
文章不深奥，不需要钻研，在公交、在地铁、在厕所都可以阅读，随时随地涨姿势。
文章不涉及代码，不烧脑细胞，人人都可以学习。
当你决定关注「编程帮」，你已然超越了90%的程序员！
微信扫描二维码关注
推荐文章 TOP10c语言-双重指针定义动态二维数组
作者：用户
浏览：730 次
双重指针定义动态二维数组5C指针符号太多了求解释每个指针符号问：?二重指针太多求解释一下各个p=(int**)malloc(sizeof(int*)*line);if(NULL==p){
双重指针定义动态二维数组
指针符号太多了 求解释每个指针符号
问：?二重指针 太多 求解释一下各个
p=(int **)malloc(sizeof(int *)*line);
if(NULL==p)
for(i=0;i&i++)
*(p+i)=(int *)malloc(sizeof(int)*row);
if(NULL==*(p+i))
首先我来看malloc做了什么，申请了一组空间，存放int型指针，返回这组空间的首地址，所以定义int **p，定义一个指向指针的指针。首地址放到p中，而p就指向了这组数，而这组数本身是指针，即定义了一个指向指针的指针了。
你可以这么考虑现在假定有一个类型是int *，申请了一组空间放int *，返回的是指向这组数的地址，是不是都是int **p了；类比int *p = （int *）malloc（sizeof（int）*num）；
解决方案二：
画个图看看，p指向一块空间（竖着画），空间里面都是放的指针，然后它们又分别指向一块空间。然后你就理解为什么会取那些line啊，row了，就是二维数组啊。（ps：就不吐槽了row和column还是对应的了）
【云栖快讯】2017互联网超级工程阿里双11完美落幕，交易额突破1682亿，但阿里工程师如何玩转“超级工程”，背后黑科技又是如何？12月13-14日，12位大咖直播分享揭秘1682亿背后技术实践，马上预约&&
稳定可靠、可弹性伸缩的在线数据库服务，全球最受欢迎的开源数据库之一
6款热门基础云产品6个月免费体验；2款产品1年体验;1款产品2年体验
弹性可伸缩的计算服务，助您降低 IT 成本，提升运维效率
开发者常用软件，超百款实用软件一站式提供C语言中二维数组行指针是什么_百度知道
色情、暴力
我们会通过消息、邮箱等方式尽快将举报结果通知您。
C语言中二维数组行指针是什么
先从存储的角度对二维数组作一个全面的了解。二维数组在内存中的存储，是按照先行后列依次存放的。从内存的角度看，可以这样说，二维数组其实就是一个一维数组，在内存中没有二维的概念。如果把二维数组的每一行看成一个整体，即看成一个数组中的一个元素，那么整个二维数组就是一个一维数组，它以每一行作为它的元素，这个应该很好理解。第一，来详细介绍二维数组与指针的关系。-首先定义个二维数组 array[3][4]，p 为指向数组的指针。若p=array[0]，此时p指向的是二维数组第一行的首地址，则 p+i 将指向array[0]数组中的元素array[0][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},{7,8,9},{10,11,12}};int * p=array[0];数组array有四个元素，分别为array[0]，array[1]，array[2]，array[3]，每个元素为包含3个元素的一维数组，如array[0]的3个元素为 array[0][0],array[0][1],array[0][2]。元素array[2][2]对应指针为：array+2*3+2，指针表示法为：*(array+2*3+2) ， 下标表示法为：array[2*3+2] 。特别注意：虽然 array[0] 与 array 都是数组首地址，但两者指向的对象不同，这点要非常明确。array[0] 是一维数组的名字，它指向的是一维数组array[0]的首地址，所以 *array[0]与array[0][0]为同个值。而 array 是二维数组的名字，它指向的是所属元素的首地址，其每个元素为一个行数组。它是以‘行’来作为指针移动单位的，如array+i 指向的是第 i 行。对 array 进行 * 运算，得到的是一维数组 array[0] 的首地址，所以 *array 与 array[0]
为同个值。如果定义 int* p，p为指int类型的指针，指向int 类型，而不是地址。故以下操作 ：p=array[0] (正确) ，p=array (错误) 。这点要非常注意。第二，看看如何用数组名作地址表示其中元素。对二维数组array ,array[0] 由 array指向，故*array 与array[0] 是相同的，依次类推可得 array[i] 由array+i 指向，*(array+i) 与array[i]是相同的。 因此，对于数组元素 array[i][j] ，用数组名表示为 *(*(array+i)+j) ，指向该元素的指针为 *(array+i)+j 。注意：数组名虽然是地址，但与指向数组的指针性质不同。指针变量可以随时改变其所指向对象，而数组名不可以，一旦被定义，就不能通过赋值使其指向另外一个数组，但是在Java中则可以。第三，顺便了解一下不太常用的‘行数组指针’。对于二维数组array[4][3]，与int* p 。二维数组名array 不能直接赋值给p。原因前面已讲过，两只的对象性质不同。 在C语言中，可以通过定义一个行数组指针，使得这个指针与二维数组名具有同样的性质，实现它们之间可以直接赋值。行数组指针定义如下：int (*p)[3]; 它表示，数组 *p 具有三个int类型元素，分别为 (*p)[0] , (*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(double (*a)[n])
采纳率：40%
就是指向每一行的指针，比如说二维数组a[2][3];a[0]代表的是二维数组第零行的首地址相当于&a[0][0];a[1]代表的是二维数组第一行的首地址相当于&a[1][0];a[0]+1代表的是二维数组第零行，第一列的地址相当于&a[0][1]
本回答被提问者采纳
行指针其实就是二级指针,也就是说它指向一个一维数组,int a[2][3];a[0] a[1] 就是行指针这么看就明白了int a[][3]={a[0],a[1]} 而a[0]
a[1]本身又是一个数组
就是指行的指针，比如指针一开始指第一行，加一就指第二行
其他1条回答
为您推荐：
其他类似问题
您可能关注的内容
二维数组的相关知识
换一换
回答问题，赢新手礼包
