二次指针与二维数组

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语言中，二维数组的定义方式为：`数据类型数组名[行个数][列个数]`。

例如：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【二维数组】一、二维数组的定义●一个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门课程的考试。

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++中多维数组做参数情况的详细解释我⼤⼆刚学完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语言多维数组与多级指针多维数组与多级指针也是初学者感觉迷糊的一个地方。

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

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

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

一、二维数组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. 直接传递二维数组直接传递二维数组是一种直接有效的方式，但其传递方式可能会导致数组元素在函数中被复制多次，从而浪费大量的内存空间。

其实二维数组和一维数组的引用方式，使用规则都是相似的。
注意严格区别：int a[3][4];和a[3][4]=3;。前者a[3][4]是定义数组， 数组大小为3行4列，而后者a[3][4]代表数组的某一个元素。
2013-8-10
《解析C程序设计（第2版）》第7章 二维数组与指针程序设计
11
二维数组的运算
2013-8-10 《解析C程序设计（第2版）》第7章 二维数组与指针程序设计 5
二维数组的定义
二维数组定义的一般形式为：
数据类型 数组名[行数][列数];
各下标仍然从0开始，取值为0、1、2、……、i-1。
元素个数=行数*列数。
2013-8-10
《解析C程序设计（第2版）》第7章 二维数组与指针程序设计
2013-8-10
《解析C程序设计（第2版）》第7章 二维数组与指针程序设计
14
二维数组的初始化
⑹键盘输入赋值 通过键盘输入二维数组的数组元素，一般需要使用二重循环的形式进行。 可以先行输入，也可先列输入。
①先行输入方式 int a[2][3]; for(i=0;i<2;i++) for(j=0;j<3;j++) scanf(“%d”,&a[i][j]);
例7-1 杨辉三角形的打印。
1 1 1 1 1
1 2 1 3 3 1 4 6 4 1
3
2013-8-10
《解析C程序设计（第2版）》第7章 二维数组与指针程序设计
问题分析
在C语言中，数组元素可以是任何类型的，特别地，数 组元素又是数组，这种数组就是多维数组。凡是具有相 同数据类型的二维表格数据，都可以使用一个数组元素 为一维数组的一维数组来表示，这种数据结构称之为二 维数组。杨辉三角形实际上是可以用一个二维数组结构 来描述的。 凡是二维及其以上维数的数组，称之为多维数组。在C 语言中，最常见的多维数组是二维数组，这种二维结构 的数据也称为矩阵。三维或多维数组虽然合法，但很少 出现。在计算机中，多维数组只是一个逻辑概念，在内 存中，多维数组元素的排列顺序“按行优先”存放，其 排列顺序为：第一维的下标变化最慢，最右边的下标变 化最快。最后形成一个就像一维数组一样的序列。

[zt]C++⼆维数组讲解、⼆维数组的声明和初始化定义：int *pia = new int[10]; // array of 10 uninitialized ints此new表达式分配了⼀个含有 10 个int型元素的数组，并返回指向该数组第⼀个元素的指针，此返回值初始化了指针pia。

在⾃由存储区中创建的数组对象是没有名字的，只能通过其地址间接地访问堆中的对象。

注意：C++使⽤new和delete在堆（⾃由存储区）上分配和释放动态数组。

动态数组初始化：1. 元素只能初始化为元素类型的默认值，⽽不能像数组变量⼀样，⽤初始化列表为数组元素提供各不相同的初值。

2. 对于内置数据类型元素的数组，必须使⽤()来显⽰指定程序执⾏初始化操作，否则程序不执⾏初始化操作：int *pia = new int[10]; // 每个元素都没有初始化int *pia2 = new int[10] (); // 每个元素初始化为03.类类型元素的数组，则⽆论是否使⽤（），都会⾃动调⽤其默认构造函数来初始化：string *psa = new string[10]; // 每个元素调⽤默认构造函数初始化string *psa = new string[10](); // 每个元素调⽤默认构造函数初始化动态分配空数组：char *cp = new char[0];之后，可以动态改变cp的维数。

动态释放：delete [] pia;典型使⽤⽰例：const char *pc = "a very long literal string"; // 处理C风格字符串时使⽤const指针const size_t len = strlen(pc) +1; // size_t⽤于数组的⼤⼩和下标for (size_t ix = 0; ix != 1000000; ++ix) {char *pc2 = new char[len]; // pc2指向的存储空间的内容会动态改变，因此不使⽤conststrncpy (pc2, pc, len); // 使⽤strncpy⽐使⽤strcpy安全// do something;delete [] pc2;}参考：⼀、数组定义和初始化1: ⼀维数组初始化：2: 标准⽅式⼀：int value[100]; // value[i]的值不定，没有初始化3: 标准⽅式⼆：int value[100] = {1,2}; // value[0]和value[1]的值分别为1和2，⽽没有定义的value[i>1]4: // 则初始化为05: 指针⽅式：int* value = new int[n]; // 未初始化6: delete []value; // ⼀定不能忘了删除数组空间7:8: ⼆维数组初始化：9: 标准⽅式⼀：int value[9][9]; // value[i][j]的值不定，没有初始化10: 标准⽅式⼆：int value[9][9] = {{1,1},{2}}；//value[0][0,1]和value[1][0]的值初始化，其他初始化为011: 指针⽅式⼀：int (*value)[n] = new int[m][n];12: delete []value; // n必须为常量，调⽤直观。

二维数组与指针（教程）二维数组与指针1．二维数组元素在内存中的存放方式在C++中，二维数组元素值在内存中是按行的顺序存放的。

若定义二维整型数组a[3][3]，假设编译系统为数组a分配的内存空间从1000开始到1035为止，则数组中各元素a[0][0]~a[2][2]在内存中按行存放次序如图7.6所示。

因此，与一维数组类似，可用指针变量来访问二维数组元素。

【例7.7】用指针变量输出二维数组各元素的值。

# include <iostream.h>void main(void){ int a[3][3]={{1,2,3},{4,5,6},{7,8,9}};int *p=&a[0][0]; //将二维数组首地址赋给指针变量pfor (int i=0;i<9;i++){ cout<<*p<<'\t'; //输出二维数组中第i个元素值p++; //指针变量p加1，指向下一个元素}}程序执行后输出结果为：1 2 3 4 5 6 7 8 9但要用上述指针变量p访问二维数组中任意指定元素a[i][j]就觉得很不方便，为此C++设计者提供另外几种访问二维数组元素的方法，为了了解访问二维数组元素的方法，必须了解三个地址概念，即：二维数组行首地址、行地址、元素地址，现介绍如下。

2．二维数组行首地址二维数组各元素按行排列可写成如图7.7所示矩阵形式，若将第i行中的元素a[i][0]、a[i][1]、a[i][2]组成一维数组a[i] (i=0,1,2)，则二维数组a[3][3]可看成是由三个一维数组元素a[0]、a[1]、a[2]组成。

即：a[3][3]=(a[0]，a[1]，a[2])，其中：a[0]、a[1]、a[2]是分别表示二维数组a[3][3]的第0、1、2行元素。

即：a[0]=(a[0][0],a[0][1],a[0][2])a[1]=(a[1][0],a[1][1],a[1][2])a[2]=(a[2][0],a[2][1],a[2][2])因为数组名可用来表示数组的首地址，所以一维数组名a[i]可表示一维数组(a[i][0],a[i][1],a[i][2])的首地址&a[i][0]，即可表示第i行元素的首地址。

多维数组的定义
•在数组定义时，多维数组的维数从左到右第一个[] 称第一维，第二个[]称第二维，依此类推。多维数组 元素的顺序仍由下标决定。下标的变化是先变最右 边的，再依次变化左边的下标。 •三维数组b的12个元素是：
b[0][0][0] b[0][1][0] b[1][0][0] b[1][1][0]
也可以只对部分元素赋值而省略第一维的长度, 但应分行赋初值。
第一维的大小为多少 ？
4.如果对全部元素赋初值, 则定义数组对第一维的长度可以不指定, 但对第二维长度不缺省。
int
int
a[3][4]={1,2,3,4,5,6,7,8,9,10,11,12};
a[ ][4]={1,2,3,4,5,6,7,8,9,10,11,12};
Enter 10 integers: 3 5 2 8 1 After sorted: 1 2 3 5 8
二维数组
若一个一维数组，它的每一个元素是(类型相同的)一维 数组时，便构成二维数组。 数组的类型相同：是指数组大小、元素类型相同。 数组的维数：是指数组的下标个数，一维数组元素只 有一个下标，二维数组元素有两个下标。 二维数组的定义 1.定义形式： 存储类别 类型标识符 数组名[行数][列数]； 例：float b[5][3]; 定义了一个5×3的数组b,即数组为5行3列，可存放15 个实型数据。
类型说明符 数组名[常量表达式1][常量表达2]......[常量表达式N] 多维数组在内存中的排列顺序为： 第一维的下标变化最慢, 最右边的下标变化最快。
•根据二维数组的定义，我们可以类推出多维数组的定义。 static int b[2][2][3]; /*定义了一个３维的静态整型数组*/ float c[2][3][2][2]； /*定义了一个４维浮点型数组*/

a[1] a[2] a[3]
mmaainn(()) {{iinntt aa[[1100] ],,ii;;
ppuuttss((““pplleeaassee iinnppuutt %%dd ssccoorree::””,,N1)0;);
ffoorr ((ii==00;;i<i1<01;0i;++i+) +) ssccaannff(“(%"%d”d,"a?,+i&a[)i;]);
main()
{
int i = 0;
printf("%c%s\n",*a, b + 1);
while (putchar (*(a + i)))
{ i++;
Program
}
printf("i = %d\n",i);
PROGRAM
while ( -- i)
{ putchar (*(b + i));
i=7
} printf("\n%s\n", &b[3]);
1,2,3,3,2,3,4,4
20
读程序－3
#include <stdio.h>
char b[] = "program";
char *a = “PROGRAM”;
/*定义一个指针变量指向字符串,与上边定义的区别是：前者是先申请内存空间， 后存入字符串，而后者是先将字符串存入在内存的某个地方，然后再用a指向 该字符串所在内存的开始位置。另外。b是常量,a是变量*/
–指针变量指向哪儿？
–所指向的变量里存储的数据是多少？

CC++——⼆维数组与指针、指针数组、数组指针（⾏指针）、⼆级指针的⽤法1. ⼆维数组和指针要⽤指针处理⼆维数组，⾸先要解决从存储的⾓度对⼆维数组的认识问题。

我们知道，⼀个⼆维数组在计算机中存储时，是按照先⾏后列的顺序依次存储的，当把每⼀⾏看作⼀个整体，即视为⼀个⼤的数组元素时，这个存储的⼆维数组也就变成了⼀个⼀维数组了。

⽽每个⼤数组元素对应⼆维数组的⼀⾏，我们就称之为⾏数组元素，显然每个⾏数组元素都是⼀个⼀维数组下⾯我们讨论指针和⼆维数组元素的对应关系，清楚了⼆者之间的关系，就能⽤指针处理⼆维数组了。

设p是指向⼆维数组a[m][n]的指针变量，则有：int* p=a[0];//此时P是指向⼀维数组的指针。

P++后，p指向 a[0][1]。

如果定义int (*p1)[n];p1=a;p1++后，p1指向a[1][0];则p+j将指向a[0]数组中的元素a[0][j]。

由于a[0]、a[1]┅a[M-1]等各个⾏数组依次连续存储，则对于a数组中的任⼀元素a[i][j]，指针的⼀般形式如下：p+i*N+j 相应的如果⽤p1来表⽰，则为*(p1+i)+j元素a[i][j]相应的指针表⽰为：*( p+i*N+j) 相应的如果⽤p1来表⽰，则为*(*(p1+i)+j)同样，a[i][j]也可使⽤指针下标法表⽰，如下：p[i*N+j]例如，有如下定义：int a[3][4]={{10,20,30,40,},{50,60,70,80},{90,91,92,93}};则数组a有3个元素，分别为a[0]、a[1]、a[2]。

⽽每个元素都是⼀个⼀维数组，各包含4个元素，如a[1]的4个元素是a[1][0]、a[1][1]、a[1]2]、a[1][3]。

若有：int *p=a[0];则数组a的元素a[1][2]对应的指针为：p+1*4+2元素a[1][2]也就可以表⽰为：*( p+1*4+2)⽤下标表⽰法，a[1][2]表⽰为：p[1*4+2]特别说明：对上述⼆维数组a，虽然a[0]、a都是数组⾸地址，但⼆者指向的对象不同，a[0]是⼀维数组的名字，它指向的是a[0]数组的⾸元素，对其进⾏“*”运算，得到的是⼀个数组元素值，即a[0]数组⾸元素值，因此，*a[0]与a[0][0]是同⼀个值；⽽a是⼀个⼆维数组的名字，它指向的是它所属元素的⾸元素，它的每⼀个元素都是⼀个⾏数组，因此，它的指针移动单位是“⾏”，所以a+i指向的是第i个⾏数组，即指向a[i]。

可设一个二维数组a[5][3]存放五个人三门课的成绩。再设一个一维数组v[3]存放所求得各分科平均成绩，设变量average为全组各科总平均成绩。编程如下：
main()
{
int i,j,s=0,average,v[3],a[5][3];
printf("input score\n");
for(i=0;i<3;i++)
C
7.1.1二维数组的定义
前面介绍的数组只有一个下标，称为一维数组，其数组元素也称为单下标变量。在实际问题中有很多量是二维的或多维的，因此Ｃ语言允许构造多维数组。多维数组元素有多个下标，以标识它在数组中的位置，所以也称为多下标变量。本小节只介绍二维数组，多维数组可由二维数组类推而得到。
二维数组定义的一般形式是：类型说明符数组名[常量表达式1][常量表达式2]
如二维数组a[3][4]，可分解为三个一维数组，其数组名分别为：
a[0]
a[1]
a[2]
对这三个一维数组不需另作说明即可使用。这三个一维数组都有4个元素，例如：一维数组a[0]的元素为a[0][0],a[0][1],a[0][2],a[0][3]。必须强调的是，a[0],a[1],a[2]不能当作下标变量使用，它们是数组名，不是一个单纯的下标变量。
在Ｃ语言中，二维数组是按行排列的。即，先存放a[0]行，再存放a[1]行，最后存放a[2]行。每行中有四个元素也是依次存放。由于数组a说明为int类型，该类型占两个字节的内存空间，所以每个元素均占有两个字节)。
1.2二维数组元素的引用
二维数组的元素也称为双下标变量，其表示的形式为：
数组名[下标][下标]
a[2][0],a[2][1],a[2][2],a[2][3]