C语言 二维数组动态分配和释放

C 二维数组动态分配和释放

(1)已知第二维
Code-1
char (*a)[N];//指向数组的指针
a = (char (*)[N])malloc(sizeof(char *) * m);
printf("%d\n", sizeof(a));//4,指针
printf("%d\n", sizeof(a[0]));//N,一维数组
free(a);
(2)已知第一维
Code-2
char* a[M];//指针的数组
int i;
for(i=0; i<M; i++)
a[i] = (char *)malloc(sizeof(char) * n);
printf("%d\n", sizeof(a));//4*M,指针数组
printf("%d\n", sizeof(a[0]));//4,指针
for(i=0; i<M; i++)
   free(a[i]);
(3)已知第一维,一次分配内存(保证内存的连续性)
Code-3
char* a[M];//指针的数组
int i;
a[0] = (char *)malloc(sizeof(char) * M * n);
for(i=1; i<M; i++)
a[i] = a[i-1] + n;
printf("%d\n", sizeof(a));//4*M,指针数组
printf("%d\n", sizeof(a[0]));//4,指针
free(a[0]);
(4)两维都未知
Code-4
char **a;
int i;
a = (char **)malloc(sizeof(char *) * m);//分配指针数组
for(i=0; i<m; i++)
{
a[i] = (char *)malloc(sizeof(char) * n);//分配每个指针所指向的数组
}
printf("%d\n", sizeof(a));//4,指针
printf("%d\n", sizeof(a[0]));//4,指针
for(i=0; i<m; i++)
{
free(a[i]);
}
free(a);
(5)两维都未知,一次分配内存(保证内存的连续性)
Code-5
char **a;
int i;
a = (char **)malloc(sizeof(char *) * m);//分配指针数组
a[0] = (char *)malloc(sizeof(char) * m * n);//一次性分配所有空间
for(i=1; i<m; i++)
{
a[i] = a[i-1] + n;
}
printf("%d\n", sizeof(a));//4,指针
printf("%d\n", sizeof(a[0]));//4,指针
free(a[0]);
free(a);
2.C++动态分配二维数组
(1)已知第二维
Code-6
char (*a)[N];//指向数组的指针
a = new char[m][N];
printf("%d\n", sizeof(a));//4,指针
printf("%d\n", sizeof(a[0]));//N,一维数组
delete[] a;
(2)已知第一维
Code-7
char* a[M];//指针的数组
for(int i=0; i<M; i++)
   a[i] = new char[n];
printf("%d\n", sizeof(a));//4*M,指针数组
printf("%d\n", sizeof(a[0]));//4,指针
for(i=0; i<M; i++)
   delete[] a[i];
(3)已知第一维,一次分配内存(保证内存的连续性)
Code-8
char* a[M];//指针的数组
a[0] = new char[M*n];
for(int i=1; i<M; i++)
a[i] = a[i-1] + n;
printf("%d\n", sizeof(a));//4*M,指针数组
printf("%d\n", sizeof(a[0]));//4,指针
delete[] a[0];
(4)两维都未知
Code-9
char **a;
a = new char* [m];//分配指针数组
for(int i=0; i<m; i++)
{
a[i] = new char[n];//分配每个指针所指向的数组
}
printf("%d\n", sizeof(a));//4,指针
printf("%d\n", sizeof(a[0]));//4,指针
for(i=0; i<m; i++)
delete[] a[i];
delete[] a;
(5)两维都未知,一次分配内存(保证内存的连续性)
Code-10
char **a;
a = new char* [m];
a[0] = new char[m * n];//一次性分配所有空间
for(int i=1; i<m; i++)
{
a[i] = a[i-1] + n;//分配每个指针所指向的数组
}
printf("%d\n", sizeof(a));//4,指针
printf("%d\n", sizeof(a[0]));//4,指针
delete[] a[0];
delete[] a;
多说一句:new和delete要注意配对使用,即有多少个new就有多少个delete,这样才可以避免内存泄漏!
3.静态二维数组作为函数参数传递
如果采用上述几种方法动态分配二维数组,那么将对应的数据类型作为函数参数就可以了。这里讨论静态二维数组作为函数参数传递,即按照以下的调用方式:
int a[2][3];
func(a);
C语言中将静态二维数组作为参数传递比较麻烦,一般需要指明第二维的长度,如果不给定第二维长度,则只能先将其作为一维指针传递,然后利用二维数组的线性存储特性,在函数体内转化为对指定元素的访问。
首先写好测试代码,以验证参数传递的正确性:
(1)给定第二维长度
Code-11
void func(int a[][N])
{
printf("%d\n", a[1][2]);
}
(2)不给定第二维长度
Code-12
void func(int* a)
{
printf("%d\n", a[1 * N + 2]);//计算元素位置
}

注意:使用该函数时需要将二维数组首地址强制转换为一维指针,即func((int*)a);

转载:http://blog.youkuaiyun.com/zyxlinux888/article/details/8070495

<think>嗯,用户想了解C语言二维数组动态分配。首先,我得回忆一下C语言的内存管理机制。动态分配通常用malloc、calloc这些函数,但二维数组的情况稍微复杂一些,因为涉及到指针指针,或者数组数组。 用户可能已经知道静态二维数组的定义,比如int arr[3][4],但动态分配需要手动管理内存,这可能让初学者困惑。我需要分步骤讲解,确保他们理解每一步的目的原理。 首先,动态分配二维数组的常见方法是使用指针数组,每个指针指向一个一维数组。这样就需要先分配一个存放指针数组,再为每一行分配内存。例如,先分配rows个int*指针,然后为每个指针分配cols个int的空间。这种方法比较直观,但需要注意释放内存的顺序,先释放每一行,再释放指针数组。 还有一种方法是使用单一的内存块,即一次性分配rows * cols的空间,然后通过计算索引来访问元素,比如arr[i][j]可以转换为arr[i*cols + j]。这种方法内存连续,可能对缓存更友好,但语法上不如指针数组直观,需要用户自己计算索引。 另外,用户可能会问这两种方法的区别适用场景。比如,指针数组的方法允许每行的长度不同,适合不规则数组,而单一内存块的方法则效率更高,适合需要连续存储的情况。 还需要注意错误处理,比如检查malloc是否返回NULL,避免内存泄漏。在示例代码中,应该包含分配失败的处理,虽然实际项目中可能更复杂,但至少要让用户意识到这一点。 用户可能遇到的常见问题包括内存泄漏、越界访问、双重释放等,所以在讲解时要强调释放内存的正确步骤,以及如何避免这些错误。 总结一下,我应该分步骤讲解两种方法,给出示例代码,并比较它们的优缺点,最后提醒注意事项。确保使用中文,结构清晰,代码正确,符合用户的请求。</think>C语言二维数组动态分配需要手动管理内存,主要涉及指针内存分配函数的使用。以下是详细的实现方法步骤: ### 一、基本原理 静态数组在编译时确定大小,而动态数组在运行时根据需求分配内存。二维数组本质上是"数组数组",动态分配时需要分两步操作: 1. 分配行指针数组 2. 为每一行分配列空间 ### 二、标准实现方法 #### 方法1:指针数组法(推荐) ```c // 分配内存 int** create_2d_array(int rows, int cols) { int** arr = (int**)malloc(rows * sizeof(int*)); if (!arr) return NULL; for (int i = 0; i < rows; i++) { arr[i] = (int*)malloc(cols * sizeof(int)); if (!arr[i]) { // 分配失败时需要释放已分配的内存 for (int j = 0; j < i; j++) free(arr[j]); free(arr); return NULL; } } return arr; } // 释放内存 void free_2d_array(int** arr, int rows) { for (int i = 0; i < rows; i++) free(arr[i]); free(arr); } ``` #### 方法2:连续内存法(高效率) ```c int** create_contiguous_2d_array(int rows, int cols) { int** arr = (int**)malloc(rows * sizeof(int*) + rows * cols * sizeof(int)); if (!arr) return NULL; int* data = (int*)(arr + rows); for (int i = 0; i < rows; i++) { arr[i] = data + i * cols; } return arr; } // 释放只需一次free void free_contiguous_2d_array(int** arr) { free(arr); } ``` ### 三、两种方法的对比 | 特性 | 指针数组法 | 连续内存法 | |---------------------|------------------------------|--------------------------| | 内存布局 | 行数据可能不连续 | 保证内存连续 | | 访问速度 | 稍慢(需要二次寻址) | 更快(缓存友好) | | 内存释放 | 需要逐行释放 | 单次释放即可 | | 灵活性 | 支持不规则二维数组 | 必须是矩形数组 | ### 四、使用示例 ```c int main() { int rows = 3, cols = 4; // 使用方法1 int** arr1 = create_2d_array(rows, cols); if (arr1) { arr1[1][2] = 5; // 赋值示例 free_2d_array(arr1, rows); } // 使用方法2 int** arr2 = create_contiguous_2d_array(rows, cols); if (arr2) { arr2[2][3] = 8; // 赋值示例 free_contiguous_2d_array(arr2); } return 0; } ``` ### 五、注意事项 1. **内存泄漏**:必须成对调用mallocfree 2. **越界访问**:需自行维护行列边界 3. **错误检查**:每次malloc后都应检查返回值 4. **初始化**:动态分配的内存不会自动清零,需要时使用calloc 5. **类型匹配**:确保指针类型转换正确 ### 六、高级技巧 1. 变长数组(C99+):对于支持C99标准的编译器,可以使用栈分配的变长数组 ```c void func(int rows, int cols) { int arr[rows][cols]; // 自动管理内存 // 但作用域仅限于函数内 } ``` 2. 结构体封装:建议将数组信息封装为结构体 ```c typedef struct { int** data; int rows; int cols; } Matrix; ``` 理解二维数组动态分配机制是掌握C语言内存管理的重要环节,建议通过实际调试观察内存布局来加深理解。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值