So I'm used to memory management in C where free(pointer)
will free up all space pointed to by pointer
. Now I'm confusing myself when attempting to do something simple in C++.
If I have a 2D array of doubles allocated in a manner similar to this
double** atoms = new double*[1000];
for(int i = 0; i < 1000; i++)
atoms[i] = new double[4];
what would be the correct method of freeing the memory on the heap allocated by new?
My thoughts were originally this (because my brain was thinking in C):
for(int i = 0; i < 1000; i++)
delete atoms[i];
delete atoms;
But I had forgotten the existence of the delete[]
operator so I believe the correct method is as follows:
for(int i = 0; i < 1000; i++)
delete[] atoms[i];
delete[] atoms;
Is it important to understand the difference between the delete
and delete[]
operators? Or can I just assume that whenever I allocate an array with ptr = new x[]
I must also deallocate it with delete[] ptr
?
To delete a 2D ordinary array, just let it go out of scope. If the 2D array is in free store, then it must be deleted with the delete[] operator to free memory in the scope in which it is declared.
To delete a dynamic array, the delete or delete[] operator is used. It deallocates the memory from heap. The delete[] keyword deletes the array pointed by the given pointer. Therefore, to delete a dynamically allocated array, we use the delete[] operator.
For dynamically allocated memory like “int *p = new int[10]”, it is the programmer's responsibility to deallocate memory when no longer needed. If the programmer doesn't deallocate memory, it causes a memory leak (memory is not deallocated until the program terminates).
A 2D array can be dynamically allocated in C using a single pointer. This means that a memory block of size row*column*dataTypeSize is allocated using malloc and pointer arithmetic can be used to access the matrix elements.
In reality, an array of pointers pointed to by a pointer is still an array of integral data types or numbers to hold the memory addresses. You should use delete[]
for both.
Also, yes, a new[]
implies a delete[]
.
When you create an array of arrays, you're actually creating an array of numbers that happen to hold the memory address for another array of numbers. Regardless, they're both arrays of numbers, so delete both with delete[]
.
http://coliru.stacked-crooked.com/a/8a625b672b66f6ce
#include <iostream>
int main() {
//Hey, pointers have a finite size, no matter the indirection level!
std::cout << "sizeof(int*): " << sizeof(int*) << std::endl;
std::cout << "sizeof(int**): " << sizeof(int**) << std::endl;
std::cout << "sizeof(int***): " << sizeof(int***) << std::endl;
//Create an array of pointers that points to more arrays
int** matrix = new int*[5];
for (int i = 0; i < 5; ++i) {
matrix[i] = new int[5];
for (int j = 0; j < 5; ++j) {
matrix[i][j] = i*5 + j;
}
}
//Print out the matrix to verify we have created the matrix
for (int j = 0; j < 5; ++j) {
for (int i = 0; i < 5; ++i) {
std::cout << matrix[j][i] << std::endl;
}
}
//Free each sub-array
for(int i = 0; i < 5; ++i) {
delete[] matrix[i];
}
//Free the array of pointers
delete[] matrix;
return 0;
}
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With