13: Creación dinámica de objetos

C proporciona las funciones de su librería estándar malloc() y sus variantes calloc() y realloc() para asignar, y free() para liberar bloques de memoria dinámicamente en tiempo de ejecución. Estas funciones son pragmáticas, pero rudimentarias, por lo que requieren comprensión y un cuidadoso manejo por parte del programador. El listado que sigue es un ejemplo que ilustra el modo de crear una instancia de una clase en el montículo con estas funciones de C:

//: C13:MallocClass.cpp
// Malloc with class objects
// What you'd have to do if not for "new"
#include "../require.h"
#include <cstdlib> // malloc() & free()
#include <cstring> // memset()
#include <iostream>
using namespace std;

class Obj {
  int i, j, k;
  enum { sz = 100 };
  char buf[sz];
public:
  void initialize() { // Can't use constructor
    cout << "initializing Obj" << endl;
    i = j = k = 0;
    memset(buf, 0, sz);
  }
  void destroy() const { // Can't use destructor
    cout << "destroying Obj" << endl;
  }
};

int main() {
  Obj* obj = (Obj*)malloc(sizeof(Obj));
  require(obj != 0);
  obj->initialize();
  // ... sometime later:
  obj->destroy();
  free(obj);
} ///:~

Observe el uso de malloc() para la obtención de espacio para el objeto:

Obj* obj = (Obj*)malloc(sizeof(Obj));

Aquí el usuario debe calcular el tamaño del objeto (una posible fuente de errores). El tipo de retorno de malloc() es void*, pues es sólo un puntero a un bloque de memoria, no un objeto. En C++ no se permite la asignación directa de un void* a ningún otro tipo de puntero, de ahí la necesidad de la conversión explícita de tipo (molde).

Puede ocurrir que malloc() no encuentre un bloque adecuado, en cuyo caso devolverá un puntero nulo, de ahí la necesidad de comprobar la validez del puntero devuelto.

El principal escollo está en la línea:

obj->initialize();

Si el usuario ha llegado hasta aquí sin errores, deberá acordarse de inicializar el objeto antes de usarlo. Obsérvese que no se ha usado el constructor debido a que éste no puede ser llamado de modo explícito^[73]; lo llama el compilador cuando se crea un objeto. El problema es que el usuario puede olvidar inicializar el objeto antes de usarlo, introduciendo así una importante fuente de problemas.

Además, parece que muchos programadores encuentran muy confusas y complicadas las funciones de asignación dinámica de la memoria en C. No es raro encontrar programadores que, usando máquinas con memoria virtual, usan arrays enormes en el área de almacenamiento estático para evitar tener que tratar con la asignación dinámica. Dado que C++ intenta que el uso de la librería sea seguro y sencillo para los programadores ocasionales, no es aceptable la forma de abordar la asignación dinámica en C.

La solución que ofrece C++ consiste en combinar la serie de acciones necesarias para la creación de un objeto en un único operador llamado new. Cuando se crea un objeto mediante el operador new, éste se encarga de obtener en el montículo el espacio necesario para el objeto y de llamar a su constructor. Cuando se ejecuta el código:

MyType *fp = new MyType(1,2);

se asigna espacio mediante alguna llamada equivalente a malloc(sizeof(MyType)) --con frecuencia es así, literalmente--, y usando la dirección obtenida como puntero this, y (1, 2) como argumentos, se llama al constructor de la clase MyType. Para cuando el puntero se asigna a fp, ya apunta a un objeto vivo e inicializado; ni siquiera es posible acceder a él antes. Además es automáticamente del tipo MyType adecuado, lo que hace innecesario el molde.

El operador new por defecto comprueba el éxito o fracaso de la asignación de memoria como paso previo a la llamada al constructor, haciendo innecesaria y redundante la posterior comprobación. Más adelante en este capítulo se verá qué sucede si se produce este fallo.

En las expresiones con new se puede usar cualquiera de los constructores disponibles para una clase. Si el constructor no tiene argumentos, se escribe la expresión sin lista de argumentos:

MyType *fp = new MyType;

Es notable la sencillez alcanzada en la creación dinámica de objetos: una única expresión realiza todo el trabajo de cálculo de tamaño, asignación, comprobaciones de seguridad y conversión de tipo. Esto hace que la creación dinámica de objetos sea tan sencilla como la creación en la pila.

El complemento a la expresión new es la expresión delete, que primero llama al destructor y después libera la memoria (a menudo mediante una llamada a free()). Del mismo modo que una expresión new devuelve un puntero al objeto, una expresión delete necesita la dirección de un objeto.

delete fp;

Esta expresión destruye el objeto y después libera el espacio dinámicamente asignado al objeto MyType creado anteriormente.

El uso del operador delete debe limitarse a los objetos que hayan sido creados mediante new. Las consecuencias de aplicar el operador delete a los objetos creados con malloc(), calloc() o realloc() no están definidas. Dado que la mayoría de las implementaciones por defecto de new y delete usan malloc() y free(), el resultado será probablemente la liberación de la memoria sin la llamada al destructor.

No ocurre nada si el puntero que se le pasa a delete es nulo. Por esa razón, a menudo se recomienda asignar cero al puntero inmediatamente después de usar delete; se evita así que pueda ser usado de nuevo como argumento para delete. Tratar de destruir un objeto más de una vez es un error de consecuencias imprevisibles.

El siguiente ejemplo demuestra que la inicialización tiene lugar:

//: C13:Tree.h
#ifndef TREE_H
#define TREE_H
#include <iostream>

class Tree {
  int height;
public:
  Tree(int treeHeight) : height(treeHeight) {}
  ~Tree() { std::cout << "*"; }
  friend std::ostream&
  operator<<(std::ostream& os, const Tree* t) {
    return os << "Tree height is: "
              << t->height << std::endl;
  }
}; 
#endif // TREE_H ///:~

//: C13:NewAndDelete.cpp
// Simple demo of new & delete
#include "Tree.h"
using namespace std;

int main() {
  Tree* t = new Tree(40);
  cout << t;
  delete t;
} ///:~

Se puede probar que el constructor es invocado imprimiendo el valor de Tree. Aquí se hace sobrecargando el operator << para usarlo con un ostream y un Tree*. Note, sin embargo, que aunque la función está declarada como friend, ¡está definida como inline! Es una mera cuestión de conveniencia --definir una función amiga como inline en una clase no cambia su condición de amiga ni el hecho de que es una función global y no un método. Observe también que el valor de retorno es el resultado de toda la expresión de salida, que es un ostream& (y así debe ser, para satisfacer el tipo del valor de retorno de la función).

Cuando se crean objetos automáticos en la pila, el tamaño de los objetos y su tiempo de vida quedan fijados en el código generado, porque el compilador conoce su tipo, cantidad y alcance. Crear objetos en el montículo implica una sobrecarga adicional, tanto en tiempo como en espacio. Veamos un escenario típico (puede reemplazar malloc() por calloc() o realloc()).

Se invoca malloc(), que pide un bloque de memoria. (Este código realmente puede ser parte de malloc()).

Ahora tiene lugar la búsqueda de un bloque de tamaño adecuado de entre los bloques libres. Esto requiere la comprobación de un mapa o directorio de algún tipo que lleve el registro de los bloques disponibles y de los que están en uso. Es un proceso rápido, pero puede que necesite varios intentos, de modo que podría no ser determinista. Dicho de otro modo, no se puede contar con que malloc() tarde siempre exactamente el mismo tiempo en cada búsqueda.

Antes de entregar el puntero al bloque obtenido, hay que registrar en alguna parte su tamaño y localización para que malloc() no lo vuelva a usar y para que cuando se produzca la llamada a free(), el sistema sepa cuánto espacio ha de liberar.

El modo en que se implementan todas estas operaciones puede variar mucho. No hay nada que impida que puedan implementarse las primitivas de asignación de memoria en el conjunto de instrucciones del procesador. Si es suficientemente curioso, puede escribir programas que permitan averiguar cómo está implementada malloc(). Si dispone de él, puede leer el código fuente de la librería de funciones de C, si no, siempre está disponible el de GNU C.