Las variables dinámicas se manejan en el montículo, y deben su nombre al hecho de que pueden ser creadas y destruidas durante el tiempo de ejecución de un módulo.

Para el manejo de variables dinámicas se hace indispensable la utilización de apuntadores, así como de funciones especiales para la asignación y liberación de la memoria correspondiente a dichas variables.

Tanto en C como en C++ existen funciones tales como malloc() y free() para la asignación y liberación de memoria del montículo.

Además de estas funciones, el C++ cuenta con dos operadores interconstruidos:

new    que realiza una labor parecida a la de la función malloc(),
       asignando un bloque de memoria. 

delete que libera un bloque de memoria asignada en tiempo de
       ejecución, de manera semejante a como lo hace free().

En el listado 6.4 se muestra un ejemplo de aplicación de los operadores new y delete.

 #include <iostream.h>

 void main()
 {
   int *apent;       // Declara un apuntador a entero

   apent = new int ; // Reserva un bloque de memoria dinámica  
            // de 2 bytes para manejarlo por medio
            // de apent.
   *apent = 10 ;     // Asigna el valor 10 al objeto apuntado  
            // por apent.
   cout << *apent ; // Despliega el contenido del objeto // apuntado por apent. delete apent ; // Libera el espacio de memoria manejado // por apent. } 

Listado 6.4.- Aplicación de new y delete.

En el programa del listado 6.4, se supone que la reservación será exitosa porque existe espacio suficiente en el montículo.

Pero ¿quién asegura que el espacio requerido por new está disponible?. Para controlar esta situación y evitar un mensaje de error por parte del sistema en tiempo de ejecución, en 6.5 se propone una nueva versión del programa.

 #include <iostream.h>
 #include <stdlib.h> // Para exit().

 void main()
 {
   int  *apent; // Declara un apuntador a entero

   if((apent = new int)==NULL)// Intenta reservar un bloque de 
      {                      // memoria dinámica  de 2 bytes ra 
                             // manejarlo por medio de apent.
	    cout << "NO hay espacio suficiente\n"; exit(1); // Finaliza la ejecución del programa. } *apent="10" ; // Asigna el valor 10 al objeto apuntado // por apent. cout << *apent ; // Despliega el contenido del objeto // apuntado por apent. delete apent ; // Libera el espacio de memoria manejado // por apent. } 

Listado 6.5.- Reservación de memoria para una variable dinámica.

Los operadores new y delete pertenecen al Lenguaje C++ , de tal manera que no se requiere incluir ningún archivo de cabecera para utilizarlos.

Para crear un arreglo de 25 elementos de tipo double, en el montículo, puede escribirse:

double* dap ;
dap = new double[25];

double* dap = new double[25];

En este ejemplo, se está declarando a dap como un apuntador a variables dinámicas de tipo doble; al tiempo que se le asigna
el valor retornado por new. El valor retornado por new es la dirección del inicio de un bloque de memoria del tamaño requerido para almacenar 25 elementos de tipo double.

En caso de que el montículo no disponga del espacio requerido, new retorna el valor NULL ( nulo ).

Aunque, cuando se requiere memoria a través de new se debe indicar el tamaño exacto del bloque requerido, el tamaño del bloque se puede dar en tiempo de ejecución como se muestra en el listado 6.6.

 #include <iostream.h>
 #include <conio.h> 
 #include <stdlib.h> 

  void main()
  {
    unsigned int n;
    clrscr();
    gotoxy(20,1);
    cout << "NUMERO DE ELEMENTOS DEL ARREGLO: "; cin>> n;
    float* apf;
    if((apf=new float[n])==NULL)
      { 
        cout << "NO HAY ESPACIO SUFICIENTE EN EL MONTICULO\N"; exit(1); } for(int x="0" ; x < n ; x++) { gotoxy(20,x+3); *(apf+x)="x+100.25;" cout << *(apf+x) << "\n"; } delete apf; getch(); } 

Listado 6.6.- Manejo de un arreglo en el montículo.

Página anterior

Página siguiente