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 to be 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++. More ahead in this same section are shown the C equivalents for these operators.

Operators new and new[ ]
In order to request dynamic memory it exists the operator new. new goes 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 the multitask interfaces 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 is recommendable to always verify if after a call to instruction new the returned pointer is null:

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 this one is no longer needed it shall be freed so that it become available for future requests of dynamic memory. For this exists the operator delete, 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, total = 0;
  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 that we request to the system as much space as it 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.