C++/C--动态二维数组的内存分配与释放：malloc 和 free&&new 和 delete

最新推荐文章于 2024-05-02 11:19:18 发布
最新推荐文章于 2024-05-02 11:19:18 发布
阅读量922 收藏
点赞数
分类专栏： c语言 c++ 嵌入式软件 文章标签： c++ c语言 内存释放 嵌入式软件开发
原文链接：https://blog.youkuaiyun.com/nyist_yangguang/article/details/127654436?spm=1001.2014.3001.5506
版权

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

1.1 数组指针的内存分配和释放


   
   
  1. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       //方法一  
      
      
    
     
     
  2. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       char (*a)[N];
       
       //指向数组的指针  
      
      
    
     
     
  3. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       a = (
       
       char (*)[N])
       
       malloc(
       
       sizeof(
       
       char [N]) * m);  
       
       //n列m行
      
      
    
     
     
  4. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
      
      
      
    
     
     
  5. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       free(a);   
      
      
    
     
     
  6. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
      
      
      
    
     
     
  7. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       //方法二  
      
      
    
     
     
  8. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       char **a;  
      
      
    
     
     
  9. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       int i;  
      
      
    
     
     
  10. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       a = (
       
       char **)
       
       malloc(
       
       sizeof(
       
       char *) * m);
       
       //分配指针数组  
      
      
    
     
     
  11. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       for(i=
       
       0; i<m; i++)  
      
      
    
     
     
  12. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           a[i] = (
       
       char *)
       
       malloc(
       
       sizeof(
       
       char) * n);
       
       //分配每个指针所指向的数组  
      
      
    
     
     
  13. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
      
      
      
    
     
     
  14. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       for(i=
       
       0; i<m; i++)  
      
      
    
     
     
  15. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
        
       
       free(a[i]);  
      
      
    
     
     
  16. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       free(a);   
      
      
    
     
     
  17. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
      
      
      
    
     
     
  18. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       //方法三  
      
      
    
     
     
  19. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       char **a;  
      
      
    
     
     
  20. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       int i;  
      
      
    
     
     
  21. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       a = (
       
       char **)
       
       malloc(
       
       sizeof(
       
       char *) * m);
       
       //分配指针数组  
      
      
    
     
     
  22. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       a[
       
       0] = (
       
       char *)
       
       malloc(
       
       sizeof(
       
       char) * m * n);
       
       //一次性分配所有空间  
      
      
    
     
     
  23. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       for(i=
       
       1; i<m; i++)  
      
      
    
     
     
  24. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           a[i] = a[i
       
       -1] + n;  
      
      
    
     
     
  25. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
      
      
      
    
     
     
  26. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       free(a[
       
       0]);  
      
      
    
     
     
  27. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       free(a);

1.2 指针数组的内存分配和释放


   
   
  1. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       //方法一  
      
      
    
     
     
  2. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       char* a[M];
       
       //指针的数组  
      
      
    
     
     
  3. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       int i;  
      
      
    
     
     
  4. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       for(i=
       
       0; i<M; i++)  
      
      
    
     
     
  5. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           a[i] = (
       
       char *)
       
       malloc(
       
       sizeof(
       
       char) * n);  
      
      
    
     
     
  6. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
      
      
      
    
     
     
  7. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       for(i=
       
       0; i<M; i++)  
      
      
    
     
     
  8. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
        
       
       free(a[i]);   
      
      
    
     
     
  9. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
      
      
      
    
     
     
  10. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       //方法二  
      
      
    
     
     
  11. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       char* a[M];
       
       //指针的数组  
      
      
    
     
     
  12. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       int i;  
      
      
    
     
     
  13. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       a[
       
       0] = (
       
       char *)
       
       malloc(
       
       sizeof(
       
       char) * M * n);  
      
      
    
     
     
  14. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       for(i=
       
       1; i<M; i++)  
      
      
    
     
     
  15. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           a[i] = a[i
       
       -1] + n;  
      
      
    
     
     
  16. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
      
      
      
    
     
     
  17. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       free(a[
       
       0]);

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

2.1 数组指针的内存分配和释放


   
   
  1. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       //方法一  
      
      
    
     
     
  2. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       char (*a)[N];
       
       //指向数组的指针  
      
      
    
     
     
  3. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       a = 
       
       new 
       
       char[m][N];  
      
      
    
     
     
  4. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
      
      
      
    
     
     
  5. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       delete[] a;   
      
      
    
     
     
  6. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
      
      
      
    
     
     
  7. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       //方法二  
      
      
    
     
     
  8. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       char **a;  
      
      
    
     
     
  9. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       a = 
       
       new 
       
       char* [m];
       
       //分配指针数组  
      
      
    
     
     
  10. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       for(
       
       int i=
       
       0; i<m; i++)  
      
      
    
     
     
  11. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           a[i] = 
       
       new 
       
       char[n];
       
       //分配每个指针所指向的数组  
      
      
    
     
     
  12. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
      
      
      
    
     
     
  13. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       for(i=
       
       0; i<m; i++)  
      
      
    
     
     
  14. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
        
       
       delete[] a[i];  
      
      
    
     
     
  15. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       delete[] a;

2.2 指针数组的内存分配和释放


   
   
  1. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       //方法一  
      
      
    
     
     
  2. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       char **a;  
      
      
    
     
     
  3. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       a = 
       
       new 
       
       char* [m];  
      
      
    
     
     
  4. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       a[
       
       0] = 
       
       new 
       
       char[m * n];
       
       //一次性分配所有空间  
      
      
    
     
     
  5. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       for(
       
       int i=
       
       1; i<m; i++)  
      
      
    
     
     
  6. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           a[i] = a[i
       
       -1] + n;
       
       //分配每个指针所指向的数组  
      
      
    
     
     
  7. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
      
      
      
    
     
     
  8. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       delete[] a[
       
       0];  
      
      
    
     
     
  9. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       delete[] a;   
      
      
    
     
     
  10. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
      
      
      
    
     
     
  11. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       //方法二  
      
      
    
     
     
  12. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       char* a[M];
       
       //指针的数组  
      
      
    
     
     
  13. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       for(
       
       int i=
       
       0; i<M; i++)  
      
      
    
     
     
  14. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
          a[i] = 
       
       new 
       
       char[n];  
      
      
    
     
     
  15. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
      
      
      
    
     
     
  16. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       for(i=
       
       0; i<M; i++)  
      
      
    
     
     
  17. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
       
       
       delete[] a[i];   
      
      
    
     
     
  18. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
      
      
      
    
     
     
  19. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       //方法三  
      
      
    
     
     
  20. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       char* a[M];
       
       //指针的数组  
      
      
    
     
     
  21. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       a[
       
       0] = 
       
       new 
       
       char[M*n];  
      
      
    
     
     
  22. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       for(
       
       int i=
       
       1; i<M; i++)  
      
      
    
     
     
  23. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           a[i] = a[i
       
       -1] + n;  
      
      
    
     
     
  24. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
      
      
      
    
     
     
  25. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       delete[] a[
       
       0];

注意： new和delete要注意配对使用，即有多少个new就有多少个delete，这样才可以避免内存泄漏！

C++二维数组动态内存分配
05-26 914
对于二维数组和二维指针的内存的分配 这里首选说一下一维指针和一维数组的内存分配情况。 一维： 数组：形如int a[5];这里定义了一个一维数组a,并且数组的元素个数是5，这里的a是这五个元素的整体表示，也就是通过a我们能找到这五个元素。注意：a是代表数组第一个元素的首地址。&a是代表数组的地址，虽然它们的值相同。 指针： int *p = NULL；这里p是一个指针，...
delete和delete[ ]的区别
最新发布
谢谢大家的关注和点赞！这里只有纯纯的知识干货，没有一句废话。希望能实实在在帮到大家～要是觉得有用，别忘了给我点支持哟，你
04-16 421
释放时用 delete[] arr;2. 调用析构函数次数不同：当操作的对象是类类型时， delete 只会调用一次析构函数，即释放单个对象时执行一次该对象的析构函数。delete[] 会为数组中的每个元素调用析构函数，比如一个类对象数组，会依次对每个对象调用析构函数来清理资源。3. 底层实现差异： delete 只是释放指针所指向的单个内存块。delete[] 除了释放内存块外，还需要知道数组的元素个数，以便正确地调用每个元素的析构函数并释放整个数组的内存空间，所以它的实现会更复杂一些。
二维数组动态分配内存
aocandr8991的博客
01-31 173
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)已知第...
c++ 动态分配二维数组 new 二维数组
weixin_33853794的博客
02-13 228
#include "stdafx.h" #include &lt;iostream&gt; using namespace std; int _tmain(int argc, _TCHAR* argv[]) { //建立一个16行5列的数组 int **p = new int*[16];//分配堆内存16个 int* for(int i = 0;i ...
C++二维动态数组的创建与删除
08-03
在C语言中，动态创建二维数组的过程与C++类似，只是使用`malloc`函数替代`new`运算符。例如，创建一个`double`类型的二维数组可以这样做： ```c double **data; data = (double **)malloc(m * sizeof(double *)); ...
C++ malloc/free/new/delete详解（内存管理）
热门推荐
TABE_的博客
12-27 1万+
这里写目录标题malloc/free典型用法内存分配实现过程new/delete典型用法内存分配实现过程new/delete和malloc/free的区别 malloc/free 典型用法 malloc()负责动态配置内存，大小由size决定，返回值成功时为任意类型指针，失败时为NULL。 void * malloc(size_t size) free()负责释放动态申请的内存空间，调用free( )后ptr所指向的内存空间被收回，如果ptr指向未知地方或者指向的空间已被收回，则会发生不可预知的错误，如果
C与C++动态分配二维数组的实现方法
08-31
本文将详细介绍如何在C和C++中使用动态内存分配创建二维数组，以及如何正确释放这些内存。 首先，让我们从C语言的角度来看。在C中，我们依赖于`malloc`和`free`这两个函数来分配和释放内存。对于二维数组，我们需要...
「C/C++ 01」指针 和 二维数组的创建
look_outs的博客
05-02 831
一、变量，指针和变量名 二、指针变量和数组变量 三、编译器对指针的等级有着严格的检查 四、如何创建一个静态的二维数组？ 五、二维数组的动态开辟和释放
为二维数组动态分配内存
ls3614140的博客
02-22 395
为二维数组动态分配内存
二维数组的动态内存分配
RZJMPB的博客
03-25 1495
#include <malloc.h> #include <iostream>using namespace std;int main(int argc, char **argv) { int n; int m=2; cout << "请输入通信录的个数： " << endl; cin >> n; int **memo; memo = (int**) ma
c++二维数组的动态分配内存
qq_43069546的博客
01-20 536
c++中二维数组动态分配内存要两步 1.先分配行的内存 2.再分配每一行的列的内存 例如生成一个n行m列的二维数组，代码如下 int **dp =(int**) malloc(n*sizeof(int)); for (int i = 0; i &lt; n; ++i) { dp[i] = (int*)malloc(m*sizeof(int)); } 注意int类型分配内存后元素...
二维数组动态内存分配
2301_80001246的博客
12-06 300
二维数组的内存分配相当于是先给一个一维数组分配内存，再在这个一维数组里面的每一个地方再开辟一块内存。
动态分配二维数组内存
hb_cqy1的博客
09-28 679
如果希望在运行时确定多维数组的维数，可以使用堆数组。动态分配二维数组内存需要使用指针的指针。多维数组的内存布局是不连续的，所以应首先为数组的第一个下标分配一个连续的数组。该数组的每个元素是指向另一个数组的指针，另一个数组保存的是第二个下标维度的元素。 分配内存的操作如下 // 动态分配二维数组及赋值 #include &amp;lt;iostream&amp;gt; using namespace std;...
[c语言]二维数组动态分配内存
07-30 584
c语言 二维数组
[原创]二维数组的动态分配及参数传递
weixin_30387423的博客
01-03 516
1. 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)...
动态内存分配二维数组怎么理解
12-27
### C/C++ 中动态内存分配创建二维数组的方法 #### 使用指针数组方式 一种方法是通过创建指向每一行的一级指针来构建二维数组。这种方式允许每行有不同的长度。 ```cpp #include <iostream> void createDynamicArrayPointer() { unsigned int rows = 0; std::cin >> rows; unsigned int cols = 0; std::cin >> cols; double **array = new double*[rows]; for (unsigned int i = 0; i < rows; ++i) { array[i] = new double[cols]{}; } // Use the array... // 清理资源 for (unsigned int i = 0; i < rows; ++i) { delete[] array[i]; } delete[] array; } ``` 此代码展示了如何为指定数量的行和列分配空间[^1]。 #### 单次 `malloc` 或者 `new` 分配大块连续内存 另一种更高效的方式是一次性分配整个二维数组所需的全部内存量，之后再按照索引访问这些数据。 ```cpp #include <cstdlib> #include <cstdio> void createContinuousMemory2DArray() { int rows = 3; int cols = 4; // 分配一块连续内存 int* array = static_cast<int*>(std::malloc(rows * cols * sizeof(int))); if (!array) { fprintf(stderr, "Failed to allocate memory\n"); exit(EXIT_FAILURE); } // 初始化并打印矩阵... // 访问元素时需注意计算偏移量 for (int row = 0; row < rows; ++row) { for (int col = 0; col < cols; ++col) { *(array + row * cols + col) = row * cols + col; printf("%d ", *(array + row * cols + col)); } puts(""); } // 不要忘记释放内存 std::free(array); } ``` 这段程序说明了一种有效率的方式来处理较大规模的数据集[^3]. #### 利用标准库容器如 `std::vector` 对于现代C++, 推荐使用STL中的`std::vector`, 它提供了自动管理大小的功能以及更好的安全性. ```cpp #include <vector> using namespace std; void useVectorFor2DArray() { size_t width = 5; size_t height = 7; vector<vector<double>> matrix(width, vector<double>(height)); // 填充matrix... } // 更简洁版本可以利用初始化列表 auto simpleMatrixCreation = [](size_t w, size_t h)->vector<vector<int>>{ return vector<vector<int>>(w,vector<int>(h)); }; // 调用 lambda 函数创建一个宽高分别为5和7的整型矩阵 simpleMatrixCreation(5, 7); ``` 上述例子表明了借助于模板类简化多维数组操作的可能性[^4].
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值