8.5.- Objetos dinámicos

En los ejemplos mostrados anteriormente se utilizaron objetos cuyo espacio de almacenamiento se manejó en la pila.

En esta sección trataremos con objetos dinámicos, cuyo espacio de almacenamiento en el montículo se asigna y se libera en tiempo de ejecución por medio de los operadores new y delete.
Por ejemplo, si existe una clase llamada punto, podemos escribir:

             punto* ap ;
            
             ap = new punto(10,20);

En la primera línea se está declarando un apuntador llamado ap, que servirá para apuntar a objetos de clase punto .

En la segunda línea se gestiona un bloque de memoria lo suficientemente grande para almacenar un objeto de la clase punto, se invoca al constructor punto pasándole los argumentos 10,20 . La dirección de inicio del bloque gestionado se asigna al apuntador ap.

Las dos líneas anteriores pueden sustituirse por:

             punto* ap = new punto(10,20);

En el listado 8.10 se presenta un ejemplo del manejo de dos objetos dinámicos, donde, además, se utiliza el polimorfismo.

En 8.10 puede observarse que se declara el apuntador ap para que apunte a objetos de clase numero y, sin embargo, ese mismo apuntador se utiliza para apuntar a objetos de clase division.

Esto se debe a que, en C++, un apuntador declarado para apuntar a objetos de una clase base puede utilizarse para apuntar a objetos de una clase derivada.

Esta regla no es válida en el sentido inverso; esto es, un apuntador declarado para apuntar a objetos de una clase derivada no puede utilizarse para apuntar a objetos de la clase base, por lo que:

     division* ap;
     ap = new numero(10);

produce un error.

  ///////////////////////////////////////////////////////      
  // OBJDIN.CPP : Muestra el uso de objetos dinámicos. //      
  ///////////////////////////////////////////////////////      
                                                               
 #include <iostream.h>                                       
                                                               
  class numero                                                 
  {                                                            
    protected:                                                 
      int valor;                                               
    public:                                                    
      numero(int numdado) { valor = numdado;}                  
      virtual int davalor(){return valor;}                     
  };                                                           
                                                               
  class division : public numero                               
  {                                                            
    protected:                                                 
      int divisor;                                             
    public:                                                    
      division(int d, int n) : numero(d) {divisor=n;}          
      virtual int davalor() {return valor/divisor;}            
  };                                                           
                                                               
  void main()                                                  
  {                                                            
    numero* ap;                                                
    ap = new numero(15);                                       
                                                               
    cout << ap->davalor() << '\n'; //Despliega 15 delete ap; ap="new" division(15,2); cout << ap->davalor() << '\n'; // Despliega 7 }

Listado 8.10.- Ejemplo de utilización de objetos dinámicos.

Página anterior Página siguiente