二次指针与二维数组

合集下载

C语言数组参数与指针参数

C语言数组参数与指针参数

C语言数组参数与指针参数我们都知道参数分为形参和实参。

形参是指声明或定义函数时的参数,而实参是在调用函数时主调函数传递过来的实际值。

一、一维数组参数1、能否向函数传递一个数组?看例子:void fun(char a[10]){char c = a[3];}intmain(){char b[10] = “abcdefg”;fun(b[10]);return 0;}先看上面的调用,fun(b[10]);将b[10]这个数组传递到fun 函数。

但这样正确吗?b[10]是代表一个数组吗?显然不是,我们知道b[0]代表是数组的一个元素,那b[10]又何尝不是呢?只不过这里数组越界了,这个b[10]并不存在。

但在编译阶段,编译器并不会真正计算b[10]的地址并取值,所以在编译的时候编译器并不认为这样有错误。

虽然没有错误,但是编译器仍然给出了两个警告:warning C4047: 'function' : 'char *' differs in levels of indirection from 'char 'warning C4024: 'fun' : different types for formal and actual parameter 1这是什么意思呢?这两个警告告诉我们,函数参数需要的是一个char*类型的参数,而实际参数为char 类型,不匹配。

虽然编译器没有给出错误,但是这样运行肯定会有问题。

如图:这是一个内存异常,我们分析分析其原因。

其实这里至少有两个严重的错误。

第一:b[10]并不存在,在编译的时候由于没有去实际地址取值,所以没有出错,但是在运行时,将计算b[10]的实际地址,并且取值。

这时候发生越界错误。

第二:编译器的警告已经告诉我们编译器需要的是一个char*类型的参数,而传递过去的是一个char 类型的参数,这时候fun 函数会将传入的char 类型的数据当地址处理,同样会发生错误。

c语言二维数组体会 -回复

c语言二维数组体会 -回复

c语言二维数组体会-回复主题:C语言二维数组体会C语言中的二维数组是一种非常常用的数据结构,它可以理解为一个表格或矩阵,由多个行和列组成。

在此文章中,我将分享我对C语言二维数组的体会和心得。

一、二维数组的概念和定义二维数组是由多个一维数组组成的数据结构,它可以看作是一个表格,横向为行,纵向为列。

在C语言中,二维数组的定义方式为:`数据类型数组名[行个数][列个数]`。

例如:cint matrix[3][3]; 定义一个3行3列的整型二维数组二维数组的每个元素可以通过`数组名[行下标][列下标]`的方式进行访问和操作。

下标从0开始,如:`matrix[0][1]`表示第一行第二列的元素。

二、二维数组的内存结构在内存中,二维数组会被连续地存储。

对于上述的`matrix`数组来说,内存中的存储方式如下:首先会依次存储第一行的元素,然后是第二行的元素,以此类推。

这种连续的存储方式使得访问元素更加高效。

三、二维数组的初始化对于二维数组的初始化,可以使用`{}`的方式进行。

例如:cint matrix[3][3] = {{1, 2, 3},{4, 5, 6},{7, 8, 9}};上述代码将数组初始化为一个3行3列的矩阵,分别填充了1到9的数字。

如果只对数组的部分元素进行初始化,则没有被初始化的元素将被自动赋值为0。

四、二维数组的遍历和操作遍历二维数组可以使用嵌套的循环结构,外层循环控制行数,内层循环控制列数。

例如,打印上述的`matrix`数组可以使用如下代码:cfor (int i = 0; i < 3; i++) {for (int j = 0; j < 3; j++) {printf("d ", matrix[i][j]);}printf("\n");}对于二维数组的操作与一维数组类似,可以进行赋值、取值、运算等操作。

例如,为每个元素乘以2可以使用如下代码:cfor (int i = 0; i < 3; i++) {for (int j = 0; j < 3; j++) {matrix[i][j] *= 2;}}通过上述循环,`matrix`数组中的每个元素都会被乘以2。

C语言知识点总结8【二维数组】

C语言知识点总结8【二维数组】

C语言知识点总结8【二维数组】一、二维数组的定义●一个3行,4列的二维数组。

其行号:0,1,2;其列号:0,1,2,3●最大下标的元素为a[2][3],没有a[3][4]这个元素●数组共有3行,每一行都是:4个元素的一维数组,每一行的数组名分别为:a[0],a[1],a[2]●从整体看,任何一个二维数组都可以看成是一个一维数组,只不过其数组元素又是一个一维数组。

●二维数组定义同时若有初始化,可以省略行号不写:如int a[][3]={1,2,3,4,5,6};系统会按照数据的个数,和规定的列数,来确定数据分几行?●二维数组定义同时若有初始化,可以省略行号不写,但列号不能省略:如int a[3][ ]={1,2,3,4,5};系统无法按照数据的个数,和规定的行数,来确定数据分几列。

二、二维数组的存储及地址关系二维数组在计算机中的存储是按行连续存储。

先保存第一行,在第一行末尾开始存第二行,依此类推。

这里,a是a[0]的地址,a[0]是数组元素a[0][0]的地址,则a是地址的地址,即二级地址三、 二维数组的初始化1、 分行赋值:int a[3][4] = {{1,2,3,4},{5,6,7,8},{9,10,11,12}};2、 不分行赋值:全部数据写在一个大括号内:int a[3][4] = {1,2,3,4,5,6,7,8,9,10,11,12};3、 部分元素赋值4、如果对全部元素赋初值,则第一维的长度可以不指定,但必须指定第二维的长度。

int a[3][4]={1,2,3,4,5,6,7,8,9,10,11,12}; 等价:int a[ ][4]={1,2,3,4,5,6,7,8,9,10,11,12};四、 二维数组的输出五、二维数组的输入六、二维数组的应用案例1:计算一个二维数组的主对角线元素之和主对角线元素的特点:行号与列号相同。

选择性求和。

反对角线元素的特点:?#include<stdio.h>void main(){int a[4][4]={{1,1,1,1},{2,2,2,2},{3,3,3,3},{4,4,4,4}};int i,j;int s=0;for(i=0;i<4;i++)for(j=0;j<4;j++)if(i==j)s=s+a[i][j];printf("%4d\n",s);}案例2:一共有5名同学,参加了3门课程的考试。

[工学]《C语言程序设计》第5章___数组、字符串、指针

[工学]《C语言程序设计》第5章___数组、字符串、指针

5.2.2 一维数组的初始化
1、数组声明时初始化 在编译阶段进行的。这样将减少运行时间, 提高效率。 数组初始化的一般形式为: 类型符 数组名[常量表达式]={值,值…值}; 例如: int a[10]={ 0,1,2,3,4,5,6,7,8,9 }; 相当于a[0]=0; a[1]=1;... a[9]=9;

a[9]
#include <stdio.h> 声明有10个元素 void main() 的一维数组a {int n,i; float s=0, ave, a[10]; a[0] a[1] … a[9] for(i=0;i<10;i++) a[i] { scanf("%f",&a[i]); a[i] s=s+a[i]; } ave=s/10; for(i=0;i<10;i++) a[i] a[i] if (a[i]>ave) printf("%f ",a[i]); }
说明: ① int a[10]={0,1,2,3,4};
给前5个元素赋 值,其余赋0值 不能给数组整体 赋值,改成{1} 静态存储类型, 初值为0 可以省略数组元 素个数。 初值的个数不能 超过元素个数
② int a[10]=1;
③ static int a[3]; ④ int a[ ]={1,2,3,4,5}; ⑤ int a[5]={1,2,3,4,5,1 };
代码: for(i=0; i<N-1; i<5; i++) { p=i; for(j=i+1; i<N; j<6; j++) if(a[j]<a[p]) p=j; t=a[i]; a[i]=a[p]; a[p]=t; } 5-5.c

数组与指针

数组与指针

此外,还可通过算术元运算对指针进行移动, 此外,还可通过算术元运算对指针进行移动,来达到引用 其他数组元素的目的。 其他数组元素的目的。 a[0] p p &a[0] *p a[0] a[1] p+1 p+1 &a[1] *(p+1) a[1] a[2] P+2 p+2 &a[2] *(p+2) a[2] a[3] P+3 p+3 &a[3] *(p+3) a[3] a[4] p+4 p+4 &a[4] *(p+4) a[4]
a[0] a[1] a[2] a[3] a[4]
a
a a+1 a+2 a+3 a+4
a a+1 a+2 a+3 a+4
&a[0] &a[1] &a[2] &a[3] &a[4]
*a *(a+1) *(a+2) *(a+3) *(a+4)
a[0] a[1] a[2] a[3] a[4]
例3: main() { int a[5],*p,i; for(i=0;i<5;i++) scanf(“%d”,a+i); for(i=0;i<5;i++) printf(“%d”,*(a+i)); }
a[1] a[1][0] a[1][1] a[1][2]
此处, 的值与 的值与a[0]的值相同,但是基类型不同。a是二级 的值相同, 此处,a的值与 的值相同 但是基类型不同。 是二级 指针, 是一级指针。 指针,a[0]是一级指针。 是一级指针 a &a[0][0] a[0] 因此,以下赋值语句是错误的: 因此,以下赋值语句是错误的:p=a; a &a[0] a+1 &a[1] a+i &a[i] *(a+i) a[i]

二维数组和二级指针的传递问题(转载)

二维数组和二级指针的传递问题(转载)

⼆维数组和⼆级指针的传递问题(转载)先看个⾃⼰的例⼦吧:Write an algorithm such that if an element in an M*N matrix is 0, its entire row and column are set to 0;//本作⽬的在于熟悉多维数组的传递# include<iostream># define ROW_N 3# define LINE_M 4using namespace std;//传递矩阵时候要说明维度……void print_matrix(int matrix_ptr[ROW_N][LINE_M]){for(int i=0;i<ROW_N;i++){for(int j=0;j<LINE_M;j++){//cout<<*(*(matrix_ptr+i)+j)<<' ';//*(*(matrix_ptr+i)+j) 和 matrix_ptr[i][j]等价cout<<matrix_ptr[i][j]<<'';}cout<<'\n';}}void clear_row(int matrix_ptr[ROW_N][LINE_M], int row){for (int i=0;i<LINE_M;i++){*(*(matrix_ptr + row)+i)=0;}}void clear_line(int matrix_ptr[ROW_N][LINE_M], int line){for (int i=0;i<ROW_N;i++){*(*(matrix_ptr+i)+line)=0;}}void checkzeropoint(int matrix_ptr[ROW_N][LINE_M]){int localmatrix[ROW_N][LINE_M];int i, j;for(i=0;i<ROW_N;i++){for(j=0;j<LINE_M;j++){localmatrix[i][j]=*(*(matrix_ptr+i)+j);}}print_matrix(localmatrix);for(i=0;i<ROW_N;i++){for(j=0;j<LINE_M;j++){if(*(*(localmatrix+i)+j)==0){cout<<"(i,j)="<<i<<','<<j<<endl;clear_row(matrix_ptr,i);clear_line(matrix_ptr,j);}}}}int main(){int matrix[3][4]={{1,2,3,4},{1,2,0,14},{9,8,6,5}};checkzeropoint(matrix);//cout <<matrix[0][0]<<endl;cout<<endl;print_matrix(matrix);return0;}原⽂链接:/?p=1822再次看这篇⽂章,感觉说的好多都是废话,在⽂章最前⾯补充⼀句话:“[]的优先级⾼于*”,⼤家可以带着这句话看下⾯的~~~========================再⼀次的见证了⾃⼰的基础不牢靠。

二重指针详解

二重指针详解朱有鹏1.二重指针1.1、二重指针与普通一重指针的区别本质上来说,二重指针和一重指针的本质都是指针变量,指针变量的本质就是变量。

一重指针变量和二重指针变量本身都占4字节内存空间,1.2、二重指针的本质(1)二重指针本质上也是指针变量,和普通指针的差别就是它指向的变量类型必须是个一重指针。

二重指针其实也是一种数据类型,编译器在编译时会根据二重指针的数据类型来做静态类型检查,一旦发现运算时数据类型不匹配编译器就会报错。

(2)C语言中如果没有二重指针行不行?其实是可以的。

一重指针完全可以做二重指针做的事情,之所以要发明二重指针(函数指针、数组指针),就是为了让编译器了解这个指针被定义时定义它的程序员希望这个指针被用来指向什么东西(定义指针时用数据类型来标记,譬如int*p,就表示p要指向int型数据),编译器知道指针类型之后可以帮我们做静态类型检查。

编译器的这种静态类型检查可以辅助程序员发现一些隐含性的编程错误,这是C 语言给程序员提供的一种编译时的查错机制。

(3)为什么C语言需要发明二重指针?原因和发明函数指针、数组指针、结构体指针等一样的。

1.3、二重指针的用法(1)二重指针指向一重指针的地址(2)二重指针指向指针数组的(3)实践编程中二重指针用的比较少,大部分时候就是和指针数组结合起来用的。

(4)实践编程中有时在函数传参时为了通过函数内部改变外部的一个指针变量,会传这个指针变量的地址(也就是二重指针)进去1.4、二重指针与数组指针(1)二重指针、数组指针、结构体指针、一重指针、普通变量的本质都是相同的,都是变量。

(2)所有的指针变量本质都是相同的,都是4个字节,都是用来指向别的东西的,不同类型的指针变量只是可以指向的(编译器允许你指向的)变量类型不同。

(3)二重指针就是:指针数组指针2、二维数组2.1、二维数组的内存映像一维数组在内存中是连续分布的多个内存单元组成的,而二维数组在内存中也是连续分布的多个内存单元组成的。

CC++中多维数组做参数情况的详细解释

CC++中多维数组做参数情况的详细解释我⼤⼆刚学完C语⾔,之后⽤来写矩阵分析的时候想把⼆维矩阵直接传到函数⾥,结果出现了问题:形参实参类型不⼀致,⽆法通过编译!随后我就尝试各种⽅法(改变形参或者实参的格式),虽然最后通过了不过当时还是没理解原理。

后来⾃⼰把原因分析出来了,现在把它写出来,希望对碰到同样问题的朋友有所帮助。

转载请注明出处,谢谢!⼏个跟参数有关的知识:C/C++的函数形参可以是普通类型、指针、引⽤。

传值⽅式有两种:值传递(包括指针)、引⽤。

传参时从左往右,结合时从右往左,这个很重要(函数默认值与此有关)。

参数是指针时,我们⼀般通过两种⽅式实现读写:①移动指针 p++ ② p+i(⽬标位置)或者 p[i],等同于寻址的⽅式实现,他们实现时在内存⾥的操作:⼀维 p+0(p[0]) p+1(p[1]) p+2(p[2]) ······ p+(n-1) (p[n-1]) 由于作图不太⽅便,下⾯的讲解就不附图了。

1、⼀维数组(指针)做参数⼀般指针做参数我就不多说了,专门搜这种问题的⼈应该都懂。

下⾯说⼀下⼀维数组:⼀般传参情况:字符串、整型数组(举个特例,实际上字符串是字符型数组)。

字符串,我们⼀般⽤下⾯这种⽅式:bool PrintStr(char* str)//char str[]也⼀样{if (NULL == str || "" == str){return false;}for (int i = 0; i < strlen(str);i++)//就不考虑效率了,注意不要⽤sizeof{cout << str[i] << " ";}while ('\0' != *str)//通过指针{cout << *str++ << " ";}return true;}2、⼆维数组做参数在⼀维中我们看到,遍历数组时必须有终⽌条件,可以是某种标志也可以规定移动次数。

C语言多维数组与多级指针

C语言多维数组与多级指针多维数组与多级指针也是初学者感觉迷糊的一个地方。

超过二维的数组和超过二级的指针其实并不多用。

如果能弄明白二维数组与二级指针,那二维以上的也不是什么问题了。

所以本节重点讨论二维数组与二级指针。

一、二维数组1、假想中的二维数组布局我们前面讨论过,数组里面可以存任何数据,除了函数。

下面就详细讨论讨论数组里面存数组的情况。

Excel 表,我相信大家都见过。

我们平时就可以把二维数组假想成一个excel表,比如:char a[3][4];2、内存与尺子的对比实际上内存不是表状的,而是线性的。

见过尺子吧?尺子和我们的内存非常相似。

一般尺子上最小刻度为毫米,而内存的最小单位为1 个byte。

平时我们说32 毫米,是指以零开始偏移32 毫米;平时我们说内存地址为0x0000FF00 也是指从内存零地址开始偏移0x0000FF00 个byte。

既然内存是线性的,那二维数组在内存里面肯定也是线性存储的。

实际上其内存布局如下图:以数组下标的方式来访问其中的某个元素:a[i][j]。

编译器总是将二维数组看成是一个一维数组,而一维数组的每一个元素又都是一个数组。

a[3]这个一维数组的三个元素分别为:a[0],a[1],a[2]。

每个元素的大小为sizeof(a[0]),即sizof(char)*4。

由此可以计算出a[0],a[1],a[2]三个元素的首地址分别为& a[0],& a[0]+1*sizof(char)*4,& a[0]+ 2*sizof(char)*4。

亦即a[i]的首地址为& a[0]+ i*sizof(char)*4。

这时候再考虑a[i]里面的内容。

就本例而言,a[i]内有4个char 类型的元素,其每个元素的首地址分别为&a[i],&a[i]+1*sizof(char),&a[i]+2*sizof(char)&a[i]+3*sizof(char),即a[i][j]的首地址为&a[i]+j*sizof(char)。

二维数组传值

二维数组传值二维数组传值是计算机程序设计中的重要概念之一。

在编程中,数组是一种可以存储多个数据类型的数据结构,而二维数组则是一种具有行和列的数组类型。

二维数组传值所指的是将一个二维数组作为参数传递给一个函数或一个对象,以实现数据处理与操作的功能。

在实际编程中,传递二维数组的方式有很多种,可以通过指针、引用或者直接传递数组来实现。

下面将介绍三种常用的传递二维数组的方式。

1. 通过指针传递二维数组通过指针传递二维数组是一种常用的方式,它可以直接传递二维数组的地址,然后在函数中通过解引用二维指针的方式来访问数组元素。

以下是一个使用指针传递二维数组的例子:void func(int **arr, int rows, int cols){for(int i = 0; i < rows; i++){for(int j = 0; j < cols; j++){printf("%d ", arr[i][j]);}printf("\n");}int main(){int arr[2][3] = {{1, 2, 3}, {4, 5, 6}};func((int **)arr, 2, 3);return 0;}2. 通过引用传递二维数组通过引用传递二维数组是一种更加安全、简单的方式,它允许函数直接使用二维数组的名称来访问数组元素。

以下是一个使用引用传递二维数组的例子:void func(int (&arr)[2][3]){for(int i = 0; i < 2; i++){for(int j = 0; j < 3; j++){printf("%d ", arr[i][j]);}printf("\n");}int main(){int arr[2][3] = {{1, 2, 3}, {4, 5, 6}};func(arr);return 0;}3. 直接传递二维数组直接传递二维数组是一种直接有效的方式,但其传递方式可能会导致数组元素在函数中被复制多次,从而浪费大量的内存空间。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

二次指针与二维数组
首先我们需要知道,什么是二次指针?下面的代码就定义了一个二次指针变量p2。

char **p2;
还是通过图来说明变量、指针变量、二次指针变量的关系吧。

对于代码:
char c = …h‟;
char *p1 = &c;
char **p2 = &p1;
其中c、p1、p2的关系如下图所示:
由于“指针生成”规则(参见教材P176)的存在,我们无法将一个数组传递给一个函数。

一个折中的解决办法是传递这个数组的第一个元素的地址,以及数组的各个维数,然后在函数中计算得到要操作的数组元素的地址来操作该数组元素。

例如:
void fun(char *p, int n, int m)//从传入指针指向元素开始,将m*n个元素赋值为5
{
for (int i = 0; i < m; i++)
for (int j = 0; j < n; j++)
*(p + i*n + j) = 5;
}
main()
{
char a[2][3];
fun(&a[0][0], 2, 3);
return 0;
}
显然,其中的fun(&a[0][0], 2, 3);对数组的操作相当于:
for (int i = 0; i < m; i++)
for (int j = 0; j < n; j++)
a[i][j] = 5;
在这段代码中,a[i][j]的形式显然更为浅显易懂,也*(p + i*n + j) = 5更为安全(不容易写错)。

接下来我们要做的,就是希望实现这样的功能:函数能够以a[i][j]这样的下标处理一个维度变化的二维数组。

通过指针数组,我们可以实现一个一维长度不同的二维数组。

当然,这也就意味着该二维数
组的元素在内存中的位置不一定连续了。

什么在指针数组呢?看如下代码:
char *pp[7];
这就是一个指针数组,它表示一个长度为7的数组pp,而数组pp的每一个元素的类型,都是char *。

也就是说,我们可以将数组pp的元素赋值给另一个指针变量,就像这样:
char *p = pp[3];
而联系到第一部分指针与一位数组之间的关系,我们可以有让数组pp的每个元素都指向不同的指针,比如说这样:
char a[13] = "ustc", b[17] = "1958";
char *t = a + 2;
char *p[5] = {a, b, t};//VC 6.0中可以用变量对数组的值进行初始化
执行以上代码之后,p[0]就指向了a数组,p[1]就指向了b数组。

而p[2]在这里的含义,也是指向一个数组。

我们可以看到,通过指针是无法获知数组的长度的。

这也就是为什么在C 语言中,字符数组后面会跟一个‟\0‟来作为结束标致。

而在操作其他类型的数组的时候,也是需要显示在代码中指定数组的长度。

printf(“%s\n”, p[2]);
上述代码执行后将输出
tc
因为printf函数在输出字符串的时候,会从传入的参数开始一直向外输出,直到遇到字符串结束标志‟\0‟。

好。

接下来我们要问了,char a[5]中,a的数据类型可以看做是一个字符指针(char *),那么char *pp[7]中,pp又是什么数据类型呢?这里pp的数据类型,就是我们本部分开始时提到的二次指针了。

我们可以通过如下代码来声明一个二次指针变量,并且并给它赋值:char *pp[7];
char **p2p = pp;
而就像我们可以对一个指针变量char *p进行指针运算p[2]或*(p + 2)获取对应的值一样,我们也可以通过如下代码获取一个指针。

char *p1, *p2;
p1 = p2p[3];
p2 = p2p[5];
而对于上述定义的p1、p2,我们还是仍然使用类似p[2]、*(p + 2)的指针运算。

于是,我们就能得到类似二维数组的使用方法了。

char a[13] = "ustc", b[17] = "1958";
char *p[5] = {a, b};//VC 6.0中可以用变量对数组的值进行初始化
char **p2p = pp;
printf(“%c\n”, pp[0][2]);
上述代码将输出一个字符‟t‟,以及换行。

好了,到此为止我们完成了对二次指针的分析。

在文章动态分配二维数组(或动态分配二维数组)当中,给出了利用二次指针动态分配二维数组的代码样例。

以及内存分配的示意图。

通过分析该文章的代码和配图,有助于我们更深入的理解二次指针。

而我们也需要在心中牢记的,是二次指针与二维数组名之间的区别。

它们是完全不同的两种数据类型。

在编程时,都可以通过类似*(*(p + 2) + 3)、p[2][3]的方式来访问一个具体的数组元素。

但是他们在计算上述表达式以获取数据时,进行的操作是不一样的。

总之,这种表达
形式上的一致性有利于我们进行编程,但同时也是让我们对他们的区别感到迷惑的根源所在。

C语言中,二维数组名与二次指针之间的关系着实令人头疼。

在进入下一步的讨论之前,先举例说明一下什么是二维数组名和二次指针。

char a2[5][8];
上述代码中,a2是一个二维数组名,而p2则是一个二次指针(指向指针的指针)
这两个概念之间错综复杂的关系之所以令人头疼,我以为主要来自以下两个方面。

其一是一维数组名与指针之间的对应关系,多少让人对二维数组与二次指针之间的关系产生亦真亦幻的遐想。

事实上,二维数组与二次指针之间没有关系,尝试编译以下代码你就知道这个想法不靠谱了:char a[5][8];
char **p;
p = a; //cannot convert from 'char [5][8]' to 'char ** '
编译这段代码,将得到一个提示为“cannot convert from 'char [5][8]' to 'char ** '”的错误。

意思是a和p的类型不一样,而且无法实现隐式转换。

在这句提示中,最让人头疼和摸不着头脑的,莫过于char [5][8]了,这是什么鬼东西?
另一个让人对二维数组与二次指针之间对应关系感到迷糊的,还在于我们确实可以通过二次指针来实现一个二维数组,也能像访问二维数组元素一样通过下标索引的方式访问二次指针指向的指向的内存空间。

具体的方法可参考这篇文章:动态分配二维数组(或动态分配二维数组)。

从这篇文章的代码极其配图讲解中,能够大致了解到二次指针与二维数组之间的关系并没有我们想想的那么简单。

至少用二次指针模拟二维数组涉及到复杂的malloc操作。

(幸好在C++中,定义了一个数组指针char (*p1)[8]之后,可以利用new操作符写出简洁明晰的表达式new int[5][8])。

相关文档
最新文档