二维数组分配，释放空间

最新推荐文章于 2024-05-17 14:46:53 发布
最新推荐文章于 2024-05-17 14:46:53 发布
阅读量710 收藏
点赞数 1
分类专栏： c基本知识 文章标签： 二维数组

http://blog.youkuaiyun.com/xcyangfan/article/details/7055028



二维数组申请与释放

[cpp]  view plain copy
  1. int nGLen=10000;//Graph length   
  2. int **test=new int* [nGLen];   
  3. for (int g=0;g <nGLen;g++)   
  4. {//malloc buffer   
  5.     test[g] = new int[MAX_GROUP_WORD_COUNT];   
  6. }   
  7.   
  8. finish = clock();    
  9. duration = finish - start;    
  10. printf( "buffer: %d\n", duration );    
  11. start=clock();   
  12.   
  13. //////////////////////////////////////////////////////////////////////////   
  14. //free temp buffer   
  15. //////////////////////////////////////////////////////////////////////////   
  16. for (int g=0;g <nGLen;g++)   
  17. {   
  18.     delete [] test[g];   
  19. }   
  20. delete [] test;   

你这根本不是“二维数组”，二维数组要求连续的地址空间，这样一次分配对应一次释放。你这个是指针一维数组，每个指针分别指向一块内存而已，只是访问方法上有点象二维数组而已。


个人不建议使用这样的二维数组。这样使用，最大的问题在于造成空间上的无数碎片，如果第一维元素多，那么循环分配和循环释放也会导致性能的极端下降。

使用所谓的二维转一维方法吧，也就是对于二维数组A[M]{N]和一维数组B[M*N]，其A[i][j]等价于B[i*N+j}，这样你就不需要用这么低效率的内存分配方式了


test[N][M]和**test分配的二维数组是有区别的，在test[N][M]中，相邻数之间是连续存储的，而在**test中，分配的每行之间的元素是连续的，但是行与行之间并不是连续的。
　堆：首先应该知道操作系统有一个记录空闲内存地址的链表，当系统收到程序的申请时，会遍历该链表，寻找第一个空间大于所申请空间的堆结点，然后将该结点从空闲结点链表中删除，并将该结点的空间分配给程序。另外，对于大多数系统，会在这块内存空间中的首地址处记录本次分配的大小。这样，代码中的delete语句才能正确的释放本内存空间。最后，由于找到的堆结点的大小不一定正好等于申请的大小，系统会自动的将多余的那部分重新放入空闲链表中。一般速度比较慢，而且容易产生内存碎片，不过用起来最方便。
你的动态分配的内存太大，而且分配次数较多，所以时间长
不是不乾淨，只是你釋放的那塊記憶體還沒人使用，所以資料還是原本的，
雖然能顯示，但是沒辦法寫入。



[cpp]  view plain copy
  1. //c++builder 帮助文件中的范例 Example of the new and delete Operators with multi-dimensional arrays:  
  2.   
  3. // ALLOCATE A TWO-DIMENSIONAL SPACE, INITIALIZE, AND DELETE IT.  
  4.   
  5. #include <exception>  
  6. #include <iostream>  
  7.   
  8. using std::cout;  
  9. using std::endl;  
  10. void display(long double **);  
  11. void de_allocate(long double **);  
  12.   
  13. int m = 3;                               // THE NUMBER OF ROWS.  
  14. int n = 5;                               // THE NUMBER OF COLUMNS.  
  15.   
  16. int main(void) {  
  17.    long double **data;  
  18.   
  19.    try {                                 // TEST FOR EXCEPTIONS.  
  20.       data = new long double*[m];        // STEP 1: SET UP THE ROWS.  
  21.       for (int j = 0; j < m; j++)  
  22.   
  23.           data[j] = new long double[n];  // STEP 2: SET UP THE COLUMNS  
  24.       }  
  25.    catch (std::bad_alloc) {  // ENTER THIS BLOCK ONLY IF bad_alloc IS THROWN.  
  26.       // YOU COULD REQUEST OTHER ACTIONS BEFORE TERMINATING  
  27.       cout << "Could not allocate. Bye ...";  
  28.       exit(-1);  
  29.       }  
  30.   
  31.    for (int i = 0; i < m; i++)  
  32.       for (int j = 0; j < n; j++)  
  33.           data[i][j] = i + j;            // ARBITRARY INITIALIZATION  
  34.   
  35.    display(data);  
  36.    de_allocate(data);  
  37.    return 0;  
  38.   
  39.    }  
  40.   
  41. void display(long double **data) {  
  42.    for (int i = 0; i < m; i++) {  
  43.         for (int j = 0; j < n; j++)  
  44.              cout << data[i][j] << " ";  
  45.        cout << "\n" << endl;  
  46.        }  
  47.    }  
  48.   
  49. void de_allocate(long double **data) {  
  50.    for (int i = 0; i < m;  i++)  
  51.        delete[] data[i];                 // STEP 1: DELETE THE COLUMNS  
  52.   
  53.    delete[] data;                        // STEP 2: DELETE THE ROWS  
  54.   
  55.    }  

二维数组申请与释放

[cpp]  view plain copy
  1. int nGLen=10000;//Graph length   
  2. int **test=new int* [nGLen];   
  3. for (int g=0;g <nGLen;g++)   
  4. {//malloc buffer   
  5.     test[g] = new int[MAX_GROUP_WORD_COUNT];   
  6. }   
  7.   
  8. finish = clock();    
  9. duration = finish - start;    
  10. printf( "buffer: %d\n", duration );    
  11. start=clock();   
  12.   
  13. //////////////////////////////////////////////////////////////////////////   
  14. //free temp buffer   
  15. //////////////////////////////////////////////////////////////////////////   
  16. for (int g=0;g <nGLen;g++)   
  17. {   
  18.     delete [] test[g];   
  19. }   
  20. delete [] test;   

你这根本不是“二维数组”，二维数组要求连续的地址空间，这样一次分配对应一次释放。你这个是指针一维数组，每个指针分别指向一块内存而已，只是访问方法上有点象二维数组而已。


个人不建议使用这样的二维数组。这样使用，最大的问题在于造成空间上的无数碎片，如果第一维元素多，那么循环分配和循环释放也会导致性能的极端下降。

使用所谓的二维转一维方法吧，也就是对于二维数组A[M]{N]和一维数组B[M*N]，其A[i][j]等价于B[i*N+j}，这样你就不需要用这么低效率的内存分配方式了


test[N][M]和**test分配的二维数组是有区别的，在test[N][M]中，相邻数之间是连续存储的，而在**test中，分配的每行之间的元素是连续的，但是行与行之间并不是连续的。
　堆：首先应该知道操作系统有一个记录空闲内存地址的链表，当系统收到程序的申请时，会遍历该链表，寻找第一个空间大于所申请空间的堆结点，然后将该结点从空闲结点链表中删除，并将该结点的空间分配给程序。另外，对于大多数系统，会在这块内存空间中的首地址处记录本次分配的大小。这样，代码中的delete语句才能正确的释放本内存空间。最后，由于找到的堆结点的大小不一定正好等于申请的大小，系统会自动的将多余的那部分重新放入空闲链表中。一般速度比较慢，而且容易产生内存碎片，不过用起来最方便。
你的动态分配的内存太大，而且分配次数较多，所以时间长
不是不乾淨，只是你釋放的那塊記憶體還沒人使用，所以資料還是原本的，
雖然能顯示，但是沒辦法寫入。



[cpp]  view plain copy
  1. //c++builder 帮助文件中的范例 Example of the new and delete Operators with multi-dimensional arrays:  
  2.   
  3. // ALLOCATE A TWO-DIMENSIONAL SPACE, INITIALIZE, AND DELETE IT.  
  4.   
  5. #include <exception>  
  6. #include <iostream>  
  7.   
  8. using std::cout;  
  9. using std::endl;  
  10. void display(long double **);  
  11. void de_allocate(long double **);  
  12.   
  13. int m = 3;                               // THE NUMBER OF ROWS.  
  14. int n = 5;                               // THE NUMBER OF COLUMNS.  
  15.   
  16. int main(void) {  
  17.    long double **data;  
  18.   
  19.    try {                                 // TEST FOR EXCEPTIONS.  
  20.       data = new long double*[m];        // STEP 1: SET UP THE ROWS.  
  21.       for (int j = 0; j < m; j++)  
  22.   
  23.           data[j] = new long double[n];  // STEP 2: SET UP THE COLUMNS  
  24.       }  
  25.    catch (std::bad_alloc) {  // ENTER THIS BLOCK ONLY IF bad_alloc IS THROWN.  
  26.       // YOU COULD REQUEST OTHER ACTIONS BEFORE TERMINATING  
  27.       cout << "Could not allocate. Bye ...";  
  28.       exit(-1);  
  29.       }  
  30.   
  31.    for (int i = 0; i < m; i++)  
  32.       for (int j = 0; j < n; j++)  
  33.           data[i][j] = i + j;            // ARBITRARY INITIALIZATION  
  34.   
  35.    display(data);  
  36.    de_allocate(data);  
  37.    return 0;  
  38.   
  39.    }  
  40.   
  41. void display(long double **data) {  
  42.    for (int i = 0; i < m; i++) {  
  43.         for (int j = 0; j < n; j++)  
  44.              cout << data[i][j] << " ";  
  45.        cout << "\n" << endl;  
  46.        }  
  47.    }  
  48.   
  49. void de_allocate(long double **data) {  
  50.    for (int i = 0; i < m;  i++)  
  51.        delete[] data[i];                 // STEP 1: DELETE THE COLUMNS  
  52.   
  53.    delete[] data;                        // STEP 2: DELETE THE ROWS  
  54.   
  55.    }  
给二维数组分配空间
guoweilkd的博客
10-21 1100
对于一维数组内存的分配，大家都很熟悉。比如分配一个256字节大小的内存堆： uint8_t *pBuff = NULL; pBuff = (uint8_t *)malloc(256); if(pBuff != NULL){ //分配成功 } 下面为给二维数组分配等同于uint8_t data[4][8]的内存堆： uint8_t **pBuff = NULL;` pBuff = (uint8_...
C语言动态分配二维数组空间
h a 6 6 6 c k 为 你解决复杂难题！
07-31 717
方法二： 当成一维数组来分配。方法一： 指针的指针。
二维数组定义以及动态分配空间
weixin_33735077的博客
10-15 241
下面三种定义形式怎么理解？怎么动态分配空间？ (1)、int **Ptr; (2)、int *Ptr[ 5 ]; 我更喜欢写成 int* Prt[5]; (3)、int ( *Ptr )[ 5 ]; 此文引自网上，出处不详，但是觉得非常好。略改了一点。 多维数组一向很难，一般都采用一维数组，但是一旦要用到还真是头疼。 闲话少说，这里我就以三个二维数...
释放二维数组
piaopiao8786的专栏
07-11 1233
听了一些牛人说，释放二维数组的应该用逐行释放 (1)已知第二维 Code-1 char (*a)[N];//指向数组的指针 a = (char (*)[N])malloc(sizeof(char *) * m);//传闻不是这样，而是a=malloc(sizeof(char)*N*m); printf("%d\n", sizeof(a));//4，指针 printf("%d\n",
为一个二维数组分配空间
瑞_板凳精神
04-08 368
先分配行，再分配列 二维数组x可以认为是：指向指针的指针 char **x template <class T> void make2dArray(T ** &X， int numberOfRows, int numberOfColumns) { //创建一个二维数组 //创建行指针 x = new T * [numberOfRows] ; //为每一行分配空间 for (int i = 0; i < numberOfRows; i++) { x[i] = ne
二维数组如何申请和释放
sanliangGoGoGo
03-04 2047
1，二维数组的申请 typedef struct dictht { dictEntry **table; unsigned long size; unsigned long sizemask; unsigned long used; } dictht; typedef struct dictEntry { void *key; union {...
C语言二维数组几种常用的表示方法
08-26
这种方法特别适合在存储空间有限的情况下使用，因为它通常会比真正的二维数组占用更少的内存空间。但缺点是需要额外的计算来确定元素的位置，可能会增加代码的复杂度。 第三种方法是指针数组来表示二维数组。在这种...
c语言二维数组的动态内存分配
aidwao的博客
12-01 4206
c语言二维数组的动态内存分配 一、 已知行（第二维），列（第一维）由用户输入： #include<stdio.h> #include<stdlib.h> void rowKnown() { int* a[3];//指针的数组 int column = 0; printf("已知行数为3，请输入列数:\n"); scanf_s("%d",&column); ...
【经验杂谈2】动态分配一维数组和二维数组
2302_79232710的博客
05-17 229
动态分配内存
关于C++动态为二维数组分配空间的问题
11-16
### 关于C++动态为二维数组分配空间的问题 在C++编程中，动态分配内存是一项非常重要的技能，尤其是在处理不确定大小的数据结构时。本文将详细解释如何使用`new`操作符来动态分配二维数组的空间，并通过示例代码...
二维数组分配内存空间
02-23 853
二维数组内存分配、释放
动态二维数组的分配与释放
rabbit729的专栏
03-29 5725
   今天在群里遇到一个询问二维数组动态申请的问题，自己想了一种办法，又在网上搜了一下，觉得下面这篇文章写得不错，特转帖如下：两种方法：1。先定义一个一维数组的类型，然后再用该类型定义一个一维数组（实际上已经成为二维的）      相当于递归定义                      typedef int array[COL];       //使用typedef定义一个具有COL个元素
二维数组的动态创建和释放
这是一个c++热爱者的博客哟
07-31 1382
如果是采取一个一个申请一维数组，那无法保证这些一维数组所形成的二维数组行指针内存连续。//运行以后，指针p非但不会消亡，其值还会保持不变，并不会变为null。此时使用if(指针!//假设p是代码块内声明的局部指针变量，在代码块执行完毕退出时，p自动消亡，但p指向的大小为8、类型为int的内存空间不会释放掉。解决方法指针被free或者delete后，一定要置为null，没有置为null的指针常称为”野指针“。//代码退出后，程序无法再通过指针p释放所申请的动态内存，这块内存已经“泄露——————内存泄漏。..
c语言为二维数组动态分配空间,二维数组定义以及动态分配空间
weixin_39853843的博客
05-22 1475
你是否正在寻找关于二维数组的内容？让我把最简洁的东西奉献给你：二维数组定义以及动态分配空间下面三种定义形式怎么理解？怎么动态分配空间？(1)、int **Ptr;(2)、int *Ptr[ 5 ]; 我更喜欢写成 int* Prt[5];(3)、int ( *Ptr )[ 5 ];此文引自网上，出处不详，但是觉得非常好。略改了一点。多维数组一向很难，一般都采用一维数组，但是一旦要用到还真是头疼。闲...
二维数组的释放
最新发布
06-19
### 正确释放二维数组内存的方法 在编程中，释放动态分配的二维数组内存是一个关键步骤，以避免内存泄漏。根据引用内容和专业实践，以下是几种常见的方法来释放二维数组的内存。 #### 方法一：使用指针数组的方式 当通过指针数组方式分配二维数组时，需要逐行释放每一行的内存，最后再释放指针数组本身的内存[^2]。具体实现如下： ```c int **b = new int*[row]; // 分配一个指针数组 for (int i = 0; i < row; i++) { b[i] = new int[col]; // 为每个指针分配一个数组 } // 使用完后释放内存 for (int i = 0; i < row; i++) { delete[] b[i]; // 先释放每一行的内存 } delete[] b; // 最后释放指针数组本身 b = NULL; // 将指针置为空，防止悬空指针 ``` #### 方法二：使用递归定义的方式 如果使用了 `typedef` 定义的递归类型来分配二维数组，则释放内存的操作相对简单[^2]。只需释放整个二维数组即可： ```c typedef int array[COL]; // 定义一个具有 COL 个元素的数组类型 array *a = new array[row]; // 为该一维数组（实际上二维）申请空间 // 使用完后释放内存 delete[] a; // 只需释放一次 a = NULL; // 将指针置为空，防止悬空指针 ``` #### 方法三：C语言中的动态分配与释放 在 C 语言中，动态分配的二维数组通常通过指针数组实现。释放内存的过程与 C++ 类似，但使用的是 `malloc` 和 `free` 函数[^1]。例如： ```c int **a = (int **) malloc(sizeof(int *) * r); // 分配指针数组 for (int j = 0; j < r; j++) { a[j] = (int *) malloc(sizeof(int) * c); // 为每一行分配内存 } // 使用完后释放内存 for (int j = 0; j < r; j++) { free(a[j]); // 先释放每一行的内存 } free(a); // 最后释放指针数组本身 a = NULL; // 将指针置为空，防止悬空指针 ``` #### 方法四：NDK 中的内存释放 在 NDK 编程中，释放 Java 数组的内存需要调用 JNI 提供的函数。以下是一个示例[^4]： ```c (*env)->ReleaseIntArrayElements(env, value, codeLineArray, 0); (*env)->ReleaseIntArrayElements(env, (jintArray)codeLineArray, codeLineData, 0); (*env)->DeleteLocalRef(env, value); (*env)->DeleteLocalRef(env, codeLineArray); (*env)->DeleteLocalRef(env, codeLineData); value = NULL; codeLineArray = NULL; codeLineData = NULL; ``` ### 注意事项 - 在释放内存时，必须按照分配的顺序反向释放，即先释放子级内存，再释放父级内存。 - 释放内存后，应将指针置为 `NULL`，以防止悬空指针问题。 - 如果程序中存在多线程操作，确保释放内存的操作是线程安全的。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值