1. 动态二维数组基本含义
与静态二维数组在栈上(stack)创建不同,动态二维数组是在堆上(heap)用malloc(或者calloc)创建。优点是数组长度在编译时不固定,可在运行时用scanf获取长度,而且长度可以在中途用realloc进行调整,缺点就是C语言不像java和python,没有garbage collection mechanism,需要用free手动释放内存空间(拉完粑粑后需要自己擦屁股),如果忘了free就会造成内存泄漏(memory leak)。以创建一个3行2列数组为例,动态创建过程如下:
#include<stdio.h>
#include<stdlib.h> //malloc函数在stdlib.h头文件中
int **dynamic_2d_array_creat(int rows, int cols);
int main(){
const int rows = 3, cols = 2;
int **dynamic_2d_array = dynamic_2d_array_creat(int rows, int cols);
return 0;
}
//动态创建二维数组
int **dynamic_2d_array_creat(int rows, int cols)
{
//堆上一片创建连续空间,存放rows个int*类型指针(即arr[i]),arr指向该空间首地址(arr[0])
int **arr = malloc(sizeof(int *) * rows);
if (!arr) //创建内存失败,提示并中止程序
{
printf("Memory allocation failed!\n");
return NULL;
}
for (int i = 0; i < rows; i++)
{
//堆上一片创建连续空间,存放cols个int类型数据,arr[i]指向该空间首地址(arr[i][0])
arr[i] = malloc(sizeof(int) * cols);
if (!arr[i]) //创建内存失败,提示并中止程序
{
printf("Memory allocation failed!\n");
return NULL;
}
}
// 初始化二维数组
int value = 1;
for (int i = 0; i < rows; i++)
{
for (int j = 0; j < cols; j++)
arr[i][j] = value++;
}
return arr;
}
1.动态创建数组需要用到malloc函数,该函数在stdlib.h头文件中;
2.创建过程是否成功需要判断,如果不成功则进行提示并中止程序
2. 动态二维数组地址分布
2.1 二级指针arr
int **arr = malloc(sizeof(int *) * rows);
1. arr是pointer to pointer,比如rows是3,则malloc在堆上创建了一片连续的内存空间,该空间存放3个int *类型的pointer(arr[0],arr[1],arr[2]),1个int *是8bytes,那么3个就是24bytes;
2. 这3个pointer在地址上是一定是连续的,假设arr[0]地址为24,则arr[1]地址为32(24+8),arr[2]地址为40(32+8);
3. arr本身有地址(假设arr地址为12),arr存放的内容为该片空间的首地址,即arr[0]的地址(24)
2.2 一级指针arr[i](arr[0],arr[1],arr[2])
for (int i = 0; i < rows; i++)
{
arr[i] = malloc(sizeof(int) * cols);
if (!arr[i])
{
printf("Memory allocation failed!\n");
return NULL;
}
}
1. arr[i]是一级指针,比如cols是2(即二维数组每行有两列),则malloc在堆上创建了一片连续的内存空间,该空间存放2个int 类型的数据(arr[i][0],arr[i][1]),1个int 是4bytes,那么2个就是8bytes。arr[0],arr[1],arr[2]表示共有三块这样的连续空间;
2.arr[0],arr[1],arr[2]本身有地址(即2.1中假设的24,32,40); 同时arr[i]中的内容也是地址,比如arr[0]存放了arr[0][0]的地址,arr[1]存放了arr[1][0]的地址,arr[2]存放了arr[2][0]的地址。假设arr[0][0]地址为64,则arr[0][1]为68(64+4);arr[1][0]地址为76,则arr[1][1]为80(76+4);arr[2][0]地址为88,则arr[2][1]为92(88+4);
3.注意:arr[0],arr[1],arr[2]代表了二维数组的3行,arr[0],arr[1],arr[2]存放着第1,2,3行首元素的地址,for循环用malloc创建1行2个元素时,这2个元素的地址必然是连续的,但是下一行的首地址未必紧接着上一行最后一个元素的地址!
4. 但如果在栈上(stack)静态创建一个二维数组int arr[3][2],这6个元素地址一定是连续的,即下一行首元素的地址必然紧接上一行最后一个元素的地址。
2.3表格展示arr,arr[i]地址分布情况
| name | addr | value | size | type |
| arr | 12 | 24 | 8bytes |
pointer to pointer (int **) |
| arr[0] | 24 | 64 | 8bytes | pointer(int *) |
| arr[1] | 32 | 76 | 8bytes | pointer(int *) |
| arr[2] | 40 | 88 | 8bytes | pointer(int *) |
| arr[0][0] | 64 | 1 | 4bytes | int |
| arr[0][1] | 68 | 2 | 4bytes | int |
| arr[1][0] | 76 | 3 | 4bytes | int |
| arr[1][1] | 80 | 4 | 4bytes | int |
| arr[2][0] | 88 | 5 | 4bytes | int |
| arr[2][1] | 92 | 6 | 4bytes | in |
3. 验证二维数组地址分布情况
3.1 动态二维数组地址分布
3.1.1代码
#include <stdio.h>
#include <stdlib.h>
//动态创建二维数组
int **dynamic_2d_array_creat(int rows, int cols);
//打印地址信息
void print_dynamic_2d_array_addr(int **arr, int rows, int cols);
//释放内存
void free_memory(int **arr);
int main()
{
const int rows = 3, cols = 2;
int **dynamic_arr_ptr = dynamic_2d_array_creat(rows, cols);
print_dynamic_2d_array_addr(dynamic_arr_ptr, rows, cols);
free_memory(dynamic_arr_ptr);
return 0;
}
int **dynamic_2d_array_creat(int rows, int cols)
{
int **arr = malloc(sizeof(int *) * rows);
if (!arr)
{
printf("Memory allocation failed!\n");
return NULL;
}
for (int i = 0; i < rows; i++)
{
arr[i] = malloc(sizeof(int) * cols);
if (!arr[i])
{
printf("Memory allocation failed!\n");
return NULL;
}
}
// 初始化二维数组
int value = 1;
for (int i = 0; i < rows; i++)
{
for (int j = 0; j < cols; j++)
arr[i][j] = value++;
}
return arr;
}
void print_dynamic_2d_array_addr(int **arr, int rows, int cols)
{
printf("+-------------+--------------+---------------+-----------+-------------+\n");
printf("| name | addr | value | size | data type |\n");
printf("+-------------+--------------+---------------+-----------+-------------+\n");
printf("| %5s | %9p | %9p | %3lu | %-10s|\n", "arr", &arr, arr, sizeof(arr), "ptr2ptr");
for (int i = 0; i < rows; i++)
printf("| arr[%d] | %9p | %9p | %3lu | %5s |\n", i, &arr[i], arr[i], sizeof(arr[i]), "ptr");
for (int i = 0; i < rows; i++)
{
for (int j = 0; j < cols; j++)
printf("| arr[%d][%d] | %9p | %5d | %3lu | %5s |\n", i, j, &arr[i][j], arr[i][j], sizeof(arr[i][j]), "int");
}
printf("+-------------+---------------+--------------+-----------+-------------+\n");
}
void free_memory(int **arr)
{
free(arr);
arr = NULL;
}
3.1.2运行结果

可以看出:
1.int **arr = malloc(sizeof(int *) * rows)创建的空间刚好存放arr[0]arr[1]arr[2]三个行指针,且地址连续:2400,2408,2410(16进制表示,间隔8个bytes),arr存放该空间的首地址即arr[0]的地址2400;
2. for (int i = 0; i < rows; i++) arr[i] = malloc(sizeof(int) * cols)创建的3块空间(即3行),每行包含2个元素且地址连续(第1行地址为2420,2424;第2行地址为2440,2444;第3行地址为2460,2464)。但是上一行与下一行地址并不连续,比如第1行第2列元素地址为2424,如果连续,第2行第1列地址应该为2428,但实际为2440。
3.2 静态二维数组地址分布
3.2.1代码
#include <stdio.h>
#include <stdlib.h>
#define ROWS 3
#define COLS 2
// 静态数组初始化
void static_2d_array_init(int (*arr)[COLS], int rows, int cols);
// 打印静态数组地址信息
void print_static_2d_array_info(int (*arr)[COLS], int rows, int cols);
int main()
{
int arr[ROWS][COLS];
static_2d_array_init(arr, ROWS, COLS);
print_static_2d_array_info(arr, ROWS, COLS);
return 0;
}
void static_2d_array_init(int (*arr)[COLS], int rows, int cols)
{
int value = 1;
for (int i = 0; i < rows; i++)
{
for (int j = 0; j < cols; j++)
arr[i][j] = value++;
}
}
void print_static_2d_array_info(int (*arr)[COLS], int rows, int cols)
{
printf("+-------------+--------------+---------------+-----------+-------------+\n");
printf("| name | addr | value | size | data type |\n");
printf("+-------------+--------------+---------------+-----------+-------------+\n");
for (int i = 0; i < rows; i++)
{
for (int j = 0; j < cols; j++)
printf("| arr[%d][%d] | %9p | %5d | %3lu | %5s |\n", i, j, &arr[i][j], arr[i][j], sizeof(arr[i][j]), "int");
}
printf("+-------------+--------------+---------------+-----------+-------------+\n");
}
3.2.2运行结果

可以看出,静态二维数组的每行各元素的地址是连续的,上一行最后一个元素与下一行首元素的地址也是连续的。
1324



被折叠的 条评论
为什么被折叠?



