Declaring an array with a fixed size like
int a[100000];
has two typical problems:
These problems can be avoided by dynamically
allocating an array of the right size, or reallocating an array when it
needs to expand. Both of these are done by declaring an array as a
pointer and using the new
operator to allocate memory,
and delete
to free memory that is no longer needed.
This is exactly what is vector
does, but let's see how it's done with an array.
new
To create a variable that will point to a dynamically allocated array, declare it as a pointer to the element type. For example,
int* a = NULL; // pointer to an int, intiallly to nothing.
A dynamically allocated array is declared as a pointer, and must not use the fixed array size declaration. The above declaration creates a pointer, but doesn't yet allocate any memory to it.
When the desired size of an array is known, allocate memory for it
with the new
operator and save the address of that memory
in the pointer. Remember: Pointers may be subscripted just as arrays are.
The example below reads in a number and allocates that size array.
int* a = NULL; // Pointer to int, initialize to nothing. int n; // Size needed for array cin >> n; // Read in the size a = new int[n]; // Allocate n ints and save ptr in a. for (int i=0; i<n; i++) { a[i] = 0; // Initialize all elements to zero. } . . . // Use a as a normal array delete [] a; // When done, free memory pointed to by a. a = NULL; // Clear a to prevent using invalid memory reference.
When you are finished with dynamically allocated memory, free it
with the delete operator. After memory is freed, it can be
reused by later new
requests. Memory that your program didn't free
will be freed when the program terminates. Never free memory that
wasn't dynamically allocated - the results are unpredictable.
delete [] a; // Free memory allocated for the a array. a = NULL; // Be sure the deallocated memory isn't used.
[]
when deleting arraysYou must specify "[]
"
when deleting an array, but not for a single value.
It isn't possible to delete only part of an array.
Following the delete
in these examples, I reset the pointer to NULL
.
This isn't strictly necessary, but it's very good practice so that any use
of the pointer will produce an error. Attempts to use memory location 0, which
is the normal default value of NULL
, will be blocked by the
way most operating systems allocate memory.
Why doesn't delete
reset the pointer? It does in some systems,
but the language specification does not require it, so not all systems do it.