Section 3.4 Dynamic memory.

Until now, in our programs, we have only had as much memory as we have requested in declarations of variables, arrays and other objects that we included, having the size of all of them fixed before the execution of the program. But, what if we need a variable amount of memory that can only be determined during the program execution (runtime), for example, in case that we need an user input to determine the necessary amount of space?

The answer is dynamic memory, for which C++ integrates the operators new and delete.

Operators new and delete are exclusive of C++. Farther ahead in this section are shown the C equivalents for these operators.

Operators new and new[ ]
In order to request dynamic memory, the operator new exists. new is followed by a data type and optionally the number of elements required within brackets []. It returns a pointer to the beginning of the new block of assigned memory. Its form is:

pointer = new type

pointer = new type [elements]

int * bobby;
bobby = new int [5];

The dynamic memory is generally managed by the operating system, and in multitask interfaces it can be shared between several applications, so there is a possibility that the memory exhausts. If this happens and the operating system cannot assign the memory that we request with the operator new, a null pointer will be returned. For that reason it is recommended to always check to see if the returned pointer is null after a call to new.

int * bobby;
bobby = new int [5];
if (bobby == NULL) {
  // error assigning memory. Take measures.
  };

Operator delete.
Since the necessity of dynamic memory is usually limited to concrete moments within a program, once it is no longer needed it should be freed so that it becomes available for future requests of dynamic memory. The operator delete exists for this purpose, whose form is:

delete pointer;

delete [] pointer;

// rememb-o-matic
#include <iostream.h>
#include <stdlib.h>

int main ()
{
  char input [100];
  int i,n;
  long * l;
  cout << "How many numbers do you want to type in? ";
  cin.getline (input,100); i=atoi (input);
  l= new long[i];
  if (l == NULL) exit (1);
  for (n=0; n<i; n++)
  {
    cout << "Enter number: ";
    cin.getline (input,100); l[n]=atol (input);
  }
  cout << "You have entered: ";
  for (n=0; n<i; n++)
    cout << l[n] << ", ";
  delete[] l;
  return 0;
}

This simple example that memorizes numbers does not have a limited amount of numbers that can be introduced, thanks to us requesting to the system to provide as much space as is necessary to store all the numbers that the user wishes to introduce.

NULL is a constant value defined in manyfold C++ libraries specially designed to indicate null pointers. In case that this constant is not defined you can do it yourself by defining it to 0:

#define NULL 0

Dynamic memory in ANSI-C

The function malloc
It is the generic function to assign dynamic memory to pointers. Its prototype is:

void * malloc (size_t nbytes);

char * ronny;
ronny = (char *) malloc (10);

int * bobby;
bobby = (int *) malloc (5 * sizeof(int));

The function calloc.
calloc is very similar to malloc in its operation, its main difference is in its prototype:

void * calloc (size_t nelements, size_t size);

int * bobby;
bobby = (int *) calloc (5, sizeof(int));

The function realloc.
It changes the size of a block of memory already assigned to a pointer.

void * realloc (void * pointer, size_t size);

The function free.
It releases a block of dynamic memory previously assigned using malloc, calloc or realloc.

void free (void * pointer);

You may obtain more information about these functions in the C++ reference for cstdlib.

© The C++ Resources Network, 2000-2001 - All rights reserved

Previous: 3-3. Pointers

index

Next: 3-5. Structures.