Dynamic Arrays

Dynamic Memory

In addition to the program stack (which is used for storing global variables and stack frames for function calls), another memory area, called the heap, is provided. The heap is used for dynamically allocating memory blocks during program execution. As a result, it is also called dynamic memory. Similarly, the program stack is also called static memory.

The new operator can be used to allocate memory at execution (run) time. It takes the following general form:

pointer_variable = new data_type;

Here, pointer_variable is a pointer of type data_type. The new operator allocates sufficient memory to hold a data object of type data_type and returns the address of this memory.

Memory for a single instance of a primitive type

int *ptr1 = new int;

float *ptr2 = new float;

Primitive types allocated from the heap via new can be initialized with some user-specified value by enclosing the value within parentheses immediately after the type name. For example,

int *ptr = new int (65); //allocates 4 bytes in dynamic memory and place in there number 65

Memory allocated from the heap does not obey the same scope rules as normal variables. For example,

void F ()

{

int* a = new int;

//...

}

when F returns, the local variable a is destroyed, but the memory block pointed to by a is not. The latter remains allocated until explicitly released by the programmer.

The delete operator is used for releasing memory blocks allocated by new. It takes a pointer as argument and releases the memory block to which it points. For example:

delete a;

Often, we do not know the size of an array at compile time. If we try to write:

int N;

N=SrtToInt(Edit1->Text);

int a [N];

– compiler rejects this, because N is a variable. In this case we must use dynamic array.

Dynamic array is array, which:

ü allocates in heap (dynamic memory) with new operator;

ü may have a variable size (but its value must be obtained before array declaration).

To get memory for an array of some primitive type using new, write the keyword new followed by the number of array elements enclosed within square brackets.

int *a = new int [ 5 ];

After this declaration we can operate with dynamic array as with static one. For example, to input the values of array a from Memo1, we can write:

for (int i = 0; i < 5; i++)

a [ i ] = StrToInt(Memo1->Lines->Strings[i]);

Note that it is not possible to initialize the individual elements of an array created when using new.

To destroy the dynamic array, we write

delete [] a;

The "[]" brackets are important. They signal the program to destroy all 5 variables, not just the first.

Dynamic arrays can be passed as function parameters just like ordinary arrays.

Дата добавления: 2014-01-11