二維數組分配，釋放空間

http://blog.csdn.net/xcyangfan/article/details/7055028

二維數組申請與釋放

int nGLen=10000;//Graph length
int **test=new int* [nGLen];
for (int g=0;g <nGLen;g++)
{//malloc buffer
    test[g] = new int[MAX_GROUP_WORD_COUNT];
}

finish = clock();
duration = finish - start;
printf( "buffer: %d\n", duration );
start=clock();

//////////////////////////////////////////////////////////////////////////
//free temp buffer
//////////////////////////////////////////////////////////////////////////
for (int g=0;g <nGLen;g++)
{
    delete [] test[g];
}
delete [] test;

你這根本不是“二維數組”，二維數組要求連續的地址空間，這樣一次分配對應一次釋放。你這個是指針一維數組，每個指針分別指向一塊內存而已，只是訪問方法上有點象二維數組而已。


個人不建議使用這樣的二維數組。這樣使用，最大的問題在於造成空間上的無數碎片，如果第一維元素多，那麼循環分配和循環釋放也會導致性能的極端下降。

使用所謂的二維轉一維方法吧，也就是對於二維數組A[M]{N]和一維數組B[M*N]，其A[i][j]等價於B[i*N+j}，這樣你就不需要用這麼低效率的內存分配方式了

test[N][M]和**test分配的二維數組是有區別的，在test[N][M]中，相鄰數之間是連續存儲的，而在**test中，分配的每行之間的元素是連續的，但是行與行之間並不是連續的。
　堆：首先應該知道操作系統有一個記錄空閒內存地址的鏈表，當系統收到程序的申請時，會遍歷該鏈表，尋找第一個空間大於所申請空間的堆結點，然後將該結點從空閒結點鏈表中刪除，並將該結點的空間分配給程序。另外，對於大多數系統，會在這塊內存空間中的首地址處記錄本次分配的大小。這樣，代碼中的delete語句才能正確的釋放本內存空間。最後，由於找到的堆結點的大小不一定正好等於申請的大小，系統會自動的將多餘的那部分重新放入空閒鏈表中。一般速度比較慢，而且容易產生內存碎片，不過用起來最方便。
你的動態分配的內存太大，而且分配次數較多，所以時間長
不是不乾淨，只是你釋放的那塊記憶體還沒人使用，所以資料還是原本的，
雖然能顯示，但是沒辦法寫入。

//c++builder 幫助文件中的範例 Example of the new and delete Operators with multi-dimensional arrays:

// ALLOCATE A TWO-DIMENSIONAL SPACE, INITIALIZE, AND DELETE IT.

#include <exception>
#include <iostream>

using std::cout;
using std::endl;
void display(long double **);
void de_allocate(long double **);

int m = 3;                               // THE NUMBER OF ROWS.
int n = 5;                               // THE NUMBER OF COLUMNS.

int main(void) {
   long double **data;

   try {                                 // TEST FOR EXCEPTIONS.
      data = new long double*[m];        // STEP 1: SET UP THE ROWS.
      for (int j = 0; j < m; j++)

          data[j] = new long double[n];  // STEP 2: SET UP THE COLUMNS
      }
   catch (std::bad_alloc) {  // ENTER THIS BLOCK ONLY IF bad_alloc IS THROWN.
      // YOU COULD REQUEST OTHER ACTIONS BEFORE TERMINATING
      cout << "Could not allocate. Bye ...";
      exit(-1);
      }

   for (int i = 0; i < m; i++)
      for (int j = 0; j < n; j++)
          data[i][j] = i + j;            // ARBITRARY INITIALIZATION

   display(data);
   de_allocate(data);
   return 0;

   }

void display(long double **data) {
   for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++)
             cout << data[i][j] << " ";
       cout << "\n" << endl;
       }
   }

void de_allocate(long double **data) {
   for (int i = 0; i < m;  i++)
       delete[] data[i];                 // STEP 1: DELETE THE COLUMNS

   delete[] data;                        // STEP 2: DELETE THE ROWS

   }

二維數組申請與釋放

int nGLen=10000;//Graph length
int **test=new int* [nGLen];
for (int g=0;g <nGLen;g++)
{//malloc buffer
    test[g] = new int[MAX_GROUP_WORD_COUNT];
}

finish = clock();
duration = finish - start;
printf( "buffer: %d\n", duration );
start=clock();

//////////////////////////////////////////////////////////////////////////
//free temp buffer
//////////////////////////////////////////////////////////////////////////
for (int g=0;g <nGLen;g++)
{
    delete [] test[g];
}
delete [] test;

你這根本不是“二維數組”，二維數組要求連續的地址空間，這樣一次分配對應一次釋放。你這個是指針一維數組，每個指針分別指向一塊內存而已，只是訪問方法上有點象二維數組而已。


個人不建議使用這樣的二維數組。這樣使用，最大的問題在於造成空間上的無數碎片，如果第一維元素多，那麼循環分配和循環釋放也會導致性能的極端下降。

使用所謂的二維轉一維方法吧，也就是對於二維數組A[M]{N]和一維數組B[M*N]，其A[i][j]等價於B[i*N+j}，這樣你就不需要用這麼低效率的內存分配方式了

test[N][M]和**test分配的二維數組是有區別的，在test[N][M]中，相鄰數之間是連續存儲的，而在**test中，分配的每行之間的元素是連續的，但是行與行之間並不是連續的。
　堆：首先應該知道操作系統有一個記錄空閒內存地址的鏈表，當系統收到程序的申請時，會遍歷該鏈表，尋找第一個空間大於所申請空間的堆結點，然後將該結點從空閒結點鏈表中刪除，並將該結點的空間分配給程序。另外，對於大多數系統，會在這塊內存空間中的首地址處記錄本次分配的大小。這樣，代碼中的delete語句才能正確的釋放本內存空間。最後，由於找到的堆結點的大小不一定正好等於申請的大小，系統會自動的將多餘的那部分重新放入空閒鏈表中。一般速度比較慢，而且容易產生內存碎片，不過用起來最方便。
你的動態分配的內存太大，而且分配次數較多，所以時間長
不是不乾淨，只是你釋放的那塊記憶體還沒人使用，所以資料還是原本的，
雖然能顯示，但是沒辦法寫入。

//c++builder 幫助文件中的範例 Example of the new and delete Operators with multi-dimensional arrays:

// ALLOCATE A TWO-DIMENSIONAL SPACE, INITIALIZE, AND DELETE IT.

#include <exception>
#include <iostream>

using std::cout;
using std::endl;
void display(long double **);
void de_allocate(long double **);

int m = 3;                               // THE NUMBER OF ROWS.
int n = 5;                               // THE NUMBER OF COLUMNS.

int main(void) {
   long double **data;

   try {                                 // TEST FOR EXCEPTIONS.
      data = new long double*[m];        // STEP 1: SET UP THE ROWS.
      for (int j = 0; j < m; j++)

          data[j] = new long double[n];  // STEP 2: SET UP THE COLUMNS
      }
   catch (std::bad_alloc) {  // ENTER THIS BLOCK ONLY IF bad_alloc IS THROWN.
      // YOU COULD REQUEST OTHER ACTIONS BEFORE TERMINATING
      cout << "Could not allocate. Bye ...";
      exit(-1);
      }

   for (int i = 0; i < m; i++)
      for (int j = 0; j < n; j++)
          data[i][j] = i + j;            // ARBITRARY INITIALIZATION

   display(data);
   de_allocate(data);
   return 0;

   }

void display(long double **data) {
   for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++)
             cout << data[i][j] << " ";
       cout << "\n" << endl;
       }
   }

void de_allocate(long double **data) {
   for (int i = 0; i < m;  i++)
       delete[] data[i];                 // STEP 1: DELETE THE COLUMNS

   delete[] data;                        // STEP 2: DELETE THE ROWS

   }