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;
}

运行结果

② 利用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++二维数组总结
传统数组内存空间：

指针数组内存空间：

仓促成文，不当之处，还请指教，欢迎讨论😀

多维数组与指针

用指针变量可以指向一维数组中的元素，也可以指向多维数组中的元素。

1) 多维数组元素的地址
设有一个二维数组 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 个元素 (即 4 个列元素)，例如，a [0] 所代表的一维数组又包含 4 个元素： a [0][0]， a [0][1]， a [0][2]， a [0][3]，如图所示。可以认为二维数组是 “数组的数组”，即数组 a 是由 3 个一维数组所组成的。
 

从二维数组的角度来看，a 代表二维数组首元素的地址，现在的首元素不是一个整型变量，而是由 4 个整型元素所组成的一维数组，因此 a 代表的是首行的起始地址 (即第 0 行的起始地址，&a [0])，a+1 代表 a [1] 行的首地址，即 & a [1]。

a [0]，a [1]，a [2] 既然是一维数组名，而 C++ 又规定了数组名代表数组首元素地址，因此 a [0] 代表一维数组 a [0] 中 0 列元素的地址，即 & a [0][0]。a [1] 的值是 & a [1][0]，a [2] 的值是 & a [2][0]。
 

0 行 1 列元素的地址可以直接写为 & a [0][1]，也可以用指针法表示。a [0] 为一维数组名，该一维数组中序号为 1 的元素显然可以用 a [0]+1 来表示。

欲得到 a [0][1] 的值，用地址法怎么表示呢？既然 a [0]+1 是 a [0][1] 元素的地址，那么，*(a [0]+1) 就是 a [0][1] 元素的值。而 a [0] 又是和 *(a+0) 无条件等价的，因此也可以用 *(*(a+0)+1) 表示 a [0][1] 元素的值。依此类推，*(a [i]+j) 或 *(*(a+i)+j) 是 a [i][j] 的值。
 

2) 指向多维数组元素的指针变量
① 指向数组元素的指针变量
【例1】输出二维数组各元素的值。这里采用的方法是用基类型为整型的指针变量先后指向各元素，逐个输出它们的值。（三种方法均可）

#include <iostream>
using namespace std;
int main()
{
	int a[3][4] = { 1,3,5,7,9,11,13,15,17,19,21,23 };
	//p是基类型为整型的指针变量
	//p = a[0]  等同于 p = &a[0][0];  也即0行首元素的地址
	int* p;                              
	for (p = a[0]; p < a[0] + 12; p++)
		cout << *p << " ";

	for (int i = 0;i<3;i++)
	{
		for (int j = 0;j<4;j++)
		{
			//cout << *(*(a + i) + j) << " ";
			cout << *(a[i] + j) << " ";
		}
	}
	cout << endl;
	return 0;
}

关于指向数组元素的指针变量的几点说明：

• p 是指向整型数据的指针变量，在 for 语句中对 p 赋初值 a [0]，也可以写成 “p=&a [0][0]”。
• 循环结束的条件是 “p<a [0]+12”，只要满足 p<a [0]+12，就继续执行循环体。
• 执行 “cout<<*p;” 输出 p 当前所指的列元素的值，然后执行 p++，使 p 指向下一个列元素。

②指向由 m 个元素组成的一维数组的指针变量

可以定义一个指针变量，它不是指向一个整型元素，而是指向一个包含 m 个元素的一维数组。这时，如果指针变量 p 先指向 a [0](即 p=&a [0])，则 p+1 不是指向 a [0][1]，而是指向 a [1]，p 的增值以一维数组的长度为单位。

【例2】输出二维数组任一行任一列元素的值。

#include <iostream>
using namespace std;
int main( )
{
    int a[3][4]={1,3,5,7,9,11,13,15,17,19,21,23};
    int (*p)[4],i,j;
    cin>>i>>j;
    p=a;
    cout<<*(*(p+i)+j)<<endl;
    return 0;
}

由于执行了 “p=a”，等同于"p = &a[0] "使 p 指向 a [0]。因此 p+2 是二维数组 a 中序号为 2 的行的起始地址 (由于 p 是指向一维数组的指针变量，因此 p 加 1，就指向下一个一维数组)。*(p+2)+3 是 a 数组 2 行 3 列元素地址。*(*(p+2)+3) 是 a [2][3] 的值。

3) 用指向数组的指针作函数参数
一维数组名可以作为函数参数传递，多维数组名也可作函数参数传递。

【例3】输出二维数组各元素的值。题目与例1相同，但本题用一个函数实现输出，用多维数组名作函数参数。

#include <iostream>
using namespace std;
int main( )
{
    void output(int (*p)[4]);  //函数声明 
    int a[3][4]={1,3,5,7,9,11,13,15,17,19,21,23};
    output(a);  //多维数组名作函数参数
    return 0;
}

//相当于  p = a;或者 p = &a[0];
void output(int (*p)[4])  //形参是指向一维数组的指针变量
{
    int i,j;
    for(i=0;i<3;i++)
        for(j=0;j<4;j++)
            cout<<*(*(p+i)+j)<<" ";
    cout<<endl;
}

指针数组和二维数组指针的区别

指针数组和二维数组指针在定义时非常相似，只是括号的位置不同：

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;
}

1. 二维数组的创建:

int arr[][];
long arr[][]; 
double arr[][];

在这,格式就是数据类型 数组名称 [ 数组的行] [ 数组的列 ];

int arr [ 3 ][ 4 ];此时就写了一个数组,这个二维数组的长度就是3行4列.

2. 二维数组的初始化:

int arr [3][4] = {1,2,3,4,5,6,7,8,9,10,11,12};

此时就是对这个二维数组进行了初始化,对这个二维数组添加了数据元素.那么此时这个二维数组初始化以后的状态就是

1	2	3	4
5	6	7	8
9	10	11	12

int arr [3][4] = {{1,2,3,4},{5,6,7,8},{9,10,11,12}};

int arr [][4] = {1,2,3,4,5,6,7,8,9,10,11,12}

对二维数组这样的遍历也是可以得到上面的情况的.

注意在二维数组的初始化时,二维数组的列是不可以省略的.

下面我们来输出一下这个二维数组:

#include<stdio.h> 
int main(){
int arr [3][4] = {1,2,3,4,5,6,7,8,9,10,11,12};
int i = 0; 
	for(i=0;i<3;i++){//因为我们数组的行和列的角标是从0开始的;这里我们从行开始
        int j = 0;
        for(j=0;j<4;j++){//这里我们从列入手

            printf("%d", arr[i][j]);//打印这个数组
        }
       printf("\n");
     }
}

 

上面代码运行以后就是我们二维数组的打印.

那么二维数组的数据元素并不是固定的嘛,那我们就来给这个二维数组添加可以自己增加数据元素的条件:

#include<stdio.h> 
int main(){
int arr [3][4] ;;
int i = 0;
	for(i=0;i<3;i++){//因为我们数组的行和列的角标是从0开始的;这里我们从行开始
        int j = 0;
        for(j=0;j<4;j++){//这里我们从列入手

            scanf("%d", &arr[i][j]);
        }
     } 
	for(i=0;i<3;i++){//因为我们数组的行和列的角标是从0开始的;这里我们从行开始
        int j = 0;
        for(j=0;j<4;j++){//这里我们从列入手

            printf("%d", arr[i][j]);//打印这个数组
        }
       printf("\n");
     }
    return 0;
}

 

那么二维数组在创建以后,我所给他的数据元素的个数并没有到达我所定义的数组的数据元素的个数时,比如说一下情况:

int arr[3][4] = {{1,2},{2,3},{3,4}}

此时我可以很明显的发现我定义的二维数组的是一个三行四列的,但是我在初始话的时候,很明显给数组的行上的数据元素不够,那么这个数组害正确嘛?

那么在C语言中,如果说你所定义的数组的长度在你初始化的时候并没有给够它足够的数据元素的时候,那么此时计算机就会自己在你的数组后面给你补齐元素数据(用0补齐).

#include<stdio.h> 
int main(){
int arr [3][4] = {1,2,3,4,5,6,7};
	int i  = 0;
	for(i = 0 ;i < 3; i ++){
		int j = 0;
		for(j = 0; j < 4;j++){
			printf("%d",arr[i][j]);
		}
		printf("\n");
	}
    return 0;
}

 

输出的结果就是:          

 那么我们定义了一个数组,我们怎么来调用数组中的元素呢?

其实我们在调用数组中的元素的时候是通过数组元素的角标来访问数组元素的.

数组的行/列	0	1	2	3
0	1	2	3	4
1	5	6	7	8
2	9	10	11	12

上面我们初始化了一个数组:如果我们要访问数组中的某一个数据元素时,我们可以通过元素的下标了查询数据元素,比如说:我们要查询的是第2行第3列的元素:也就是我们的7,那么我们此时可以访问

arr[1][2]

那么为什么我在访问的时候,输入的是arr[1][2]不是arr[2][3]呢?那么在数组中,数组元素的下角标是从0开始的,行与列都是从0开始.

数组越界:数组角标是从0开始,最后一个元素是n-1,访问的数组的元素的角标的数字大于数组角标的最大值或者小于最小值,就出现了角标的越界. 角标越界的时候有时编译器不会报错.(C语言不做数组角标越界的检查,需要本人自己检查)

那么我们在访问二维数组的时候出现了这样的数组角标越界呢

arr [2][3] = {1,2,3,4,5,6}//我定义一个两行三列的数组,那么我此时在访问的时候不小心写错了
printf("%d",arr[0][3]);//此时我访问的数据元素是数组的第一行第四列的元素

那么此时我所访问的数据元素很明显出现了越界的情况,那么此时还会访问到元素嘛?在这就需要给大家说明一下二维数组在内存储空间中的位置.

在内存储空间中,二维数组是连续存储的,当我们访问的位置超出了第一行的角标的时候,此时就会直接越界到第二行去查找第一行后面的元素,也就是说,我们刚刚查找的数据元素是可以打印出来的,第一行第四列的元素并没有,但是会访问到第二行的第一列的元素,所以我们上面的代码是可以访问到数据元素的,它的输出值就是4,那么此时出现了数组的角标越界,那么程序仍然可以执行并且不会报错,所以以后在写代码的时候需要自己多注意这些细节,避免出现数组角标越界的情况.

 数组作为函数参数:数组在传参的时候只需要加上数组名 ,在这作为传参的时候,就不得不拿出我们的一个排序算法来给大家举例子了.

 注意:  在函数内部传数组时,其实传过去的是一个指针,如果说需要传过去数组的大小的时候,我们可以在函数外面传数组的长度,这样就可以防止传进去的指针不等于数组的长度从而出现排序中的错误.

 在函数外部传数组的长度值:

#include<stdio.h>
void paixu(int arr[],int size) {
	int i = 0; 
	for (i = 0; i < size; i++) {
		int j = 0;
		for (j = 0; j < size- i-1 ; j++) {
			if (arr[j] < arr[j+1]) {
				int tep = arr[j+1];
				arr[j+1] = arr[j];
				arr[j] = tep;
			}
		}
	}
}
int main() {
	int arr[] = {1,2,3,4,5,6};//我们定义一个数组 
	int size = sizeof(arr) / sizeof(arr[0]);
	paixu(arr,size);
	int i = 0;
	for (i = 0; i < size; i++) {
		printf("%d", arr[i]);
	}
	return 0;
}

此时我们发现这样的一个冒泡排序就可以正常的排序

那我们在函数内部传数组的长度:

#include<stdio.h>
void paixu(int arr[]) {
	int i = 0;
	int size = sizeof(arr) / sizeof(arr[0]);
	for (i = 0; i < size; i++) {
		int j = 0;
		for (j = 0; j < size - i - 1; j++) {
			if (arr[j] < arr[j + 1]) {
				int tep = arr[j + 1];
				arr[j + 1] = arr[j];
				arr[j] = tep;
			}
		}
	}
}
int main() {
	int arr[] = { 1,2,3,4,5,6 };//我们定义一个数组 
	int size = sizeof(arr) / sizeof(arr[0]);
	paixu(arr);
	int i = 0;
	for (i = 0; i < size; i++) {
		printf("%d", arr[i]);
	}
	return 0;
}

此时我们们发现,在函数的里面传送数组的长度的时候,并没有排序

 这在我们给大家输出一下此时的size的值

void paixu(int arr[]) {
	int i = 0;
	int size = sizeof(arr) / sizeof(arr[0]);

 此时输出的size的值是1,说明我们在函数的内部传进去以后,我们只循环了一次,说明我们的循环就没有执行.

 
 在函数内部传数组时,其实传过去的是一个指针,如果说需要传过去数组的大小的时候,我们可以在函数外面传数组的长度,这样就可以防止传进去的指针不等于数组的长度从而出现排序中的错误. 什么意思呢?就是我们在上面的排序的函数中传过去的数组,它并不是真正的数组,而是指针的变量.,在这里要给大家说明一下,数组的名字它本质上是这个数组首元素的地址.下面给大家来演示一下:

int main() {
	int arr[] = {1,2,3,4,5,6};//我们定义一个数组 
	printf("%d", arr);
	return 0;
}

 

 此时我们看,我输出的数组的名,它并没有输出整个数组的值,而是输出了一串数字,那么这个数字就是这个数组首元素在内存储空间的一个位置.

数组名是什么?:数组名能表示首元素的地址,但是有两个例外.
 1.sizeof(数组名):计算整个数组的大小 单位是字节 
 2.&数组名,数组名表示的是整个数组,表示的是整个数组的地址
 整个数组的地址+1表示的是地址是数组的最后的一个元素的后一位的地址.
 int n = sizeof(arr);//打印出n是?

#include<stdio.h>

int main() {
	int arr[] = { 1,2,3,4,5,6 };//我们定义一个数组 
	int n = sizeof(arr);
	printf("%d", n);
	return 0;
}

 

 此时输出的n的值是24,它输出的整个数组的一个长度,它里面有6个元素,每个元素占用4个比特位,

 二维数组名的理解:二维数组的数组名也表示数组首元素的地址,表示的是二维数组的第一行的元素的地址.(将二维数组看成一维数组)

int main() {
	int arr[3][2] = { 1,2,3,4,5,6 };//我们定义一个数组 
	printf("%p", arr);
	printf("\n");
	printf("%p", arr[0]);
	return 0;
}

 

发现数组名所表示的和数组首元素的地址是一样的.所以说二维数组的数组名也表示数组首元素的地址.
 arr 和arr+1相差的地址是一行的元素的距离.

int main() {
	int arr[3][2] = { 1,2,3,4,5,6 };//我们定义一个数组 
	printf("%p\n", arr);
	printf("%p\n", arr + 1);
	printf("----------------\n");
	printf("%p\n", arr[0]);
	printf("%p\n", arr[0]+1);
	return 0;
}

 我们看到给数组名+1的时候,输出的值相差了8,给数组首元素的地址+1的时候发现增加了4,那么在二维数组中,如果说是给二维数组名的地址+1的时候,此时地址相差了一行数据的位数,上述代码中也就是两个数据元素8个比特位.(&arr 取得是整个二维数组的地址.)

数组的长度:sizeof(arr)/sizeof(arr[0])//表示的是数组的元素的个数,在这为什么要除以呢,因为sizeof(数组名)表示的是整个数组中的所有数据元素所占的内存空间,它除以其中的一个数据元素的存储空间就是整个数组的长度,在这大家要注意,不要混淆.下面代码给大家解释一下;

#include<stdio.h>

int main() {
	int arr[]= { 1,2,3,4,5,6 };//我们定义一个数组 
	int i = sizeof(arr);
	printf("%d\n", i);
	int j = sizeof(arr) / sizeof(arr[0]);
	printf("%d\n", j);
	return 0;
}

本次的分享就到这结束了!期待我们下期再见.