二维数组分配，释放空间

http://blog.csdn.net/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.    }