How do I free up memory for a dynamically created string array? ?

panshen

char ** Buffer = new char * [1000];


Use delete Buffer; or delete [] Buffer;

verance

delete [] Buffer is right, your misunderstanding is that after you think that after release,
Buffer value should correspond to a "released" state

But in the centuries, as a pointer, it was represented as an integer (or something similar),
This integer indicates the address (physical address or virtual address) of the variable or array in memory.
After the content of the pointed address is released, this piece of memory can no longer be accessed unless
Another pointer points to it.

But your pointer variable is not like this, it still retains this integer, corresponding to a certain address,
But you do n’t need to worry, the memory pointed to has already been released correctly.

The good style is that after you delete [] buf ;, you write buf = 0, which can avoid some
Unnecessary confusion

verance

The sentence above is not accurate. The last sentence of the second paragraph should be: After the content of the address pointed to is released,
This piece of memory can no longer be accessed unless it is reallocated and another pointer points to it.

panshen

Thank youverance, use the task manager to monitor the memory, use Buffer to store the contents of the read text file, read the 10MB file, delete [] Buffer; Buffer = NULL; and find that the memory has not been released yet.

Why is that?

panshen

BCB's TStringList is very inefficient, very obvious when the file is large
Dump content into Buffer


TStringList * List = new TStringList ();
List-> LoadFromFile ("Dir.txt");
int NCount = List-> Count;
char ** Buffer = new char * [NCount];

    for (int i = 0; i <NCount; i ++)
    {
     int len ​​= NetList-> Strings [i] .Length ();
     * Buffer = new char [len + 1];
     strcpy (* Buffer, List-> Strings [i] .c_str ());
     ** Buffer ++;
    }
//

....
//
delete List; // this can be released
delete [] Buffer; // This doesn't seem to work

superandy

Your delete simply returns memory from your program to the system heap management function.
The task monitor monitors the memory requested by the system heap management function from OS.
This is 2 yards.

verance

Whatsuperandysaid might be a possibility. In this case, there is nothing for you.

There is another possibility:
Is it because after you have allocated 1000 pointers, you use these thousand pointers to point to a thousand dynamically allocated memory areas,
And before releasing the pointer array, you didn't release this thousand memory areas, causing a leak? ? ?

goodjianli

char ** Buffer = new char * [100];
for (int i = 0; i <100; i ++) {
delete Buffer [i];
}

delete Buffer;

panshen

Thanks togoodjianli, the test was successful