constructor y destructor en programación orientada a objetos

constructor:

En programación orientada a objetos (POO), un constructor es una subrutina cuya misión es inicializar un objeto de una clase. En el constructor se asignan los valores iniciales del nuevo objeto.

Se utiliza para crear tablas de clases virtuales y poder así desarrollar el polimorfismo, una de las herramientas de la programación orientada a objetos. Al utilizar un constructor, el compilador determina cual de los objetos va a responder al mensaje (virtual) que hemos creado. Tiene un tipo de acceso, un nombre y un paréntesis.

ejemplo:

#include <iostream.h>
 class pareja
 {
   public:
    //Constructor
    pareja(int a2, int b2);
    //Funciones miembros de la clase "pareja"
    void Lee(int &a2, int &b2);
    void Guardar(int a2, int b2);
   private:
    //Datos miembros de la clase "pareja"
    int a, b;
 }
 pareja::pareja(int a2, int b2)
 {
    a = a2;
    b = b2;
 }
 void pareja::Lee(int &a2, int &b2)
 {
    a2 = a;
    b2 = b;
 }
 void pareja::Guarda(int a2, int b2)
 {
    a = a2;
    b = b2;
 }
 int main(int argc, char *argv[])
 {
    pareja par1(12, 32);
    int x, y;
    par1.Lee(x, y);
    cout << "Valor de par1.a: " << x <<endl;
    cout << "Valor de par2.b: " << x <<endl;
    return 0;
 }

destructores:

Un destructor en programación orientada a objetos es una función miembro especial llamadas automáticamente en la ejecución del programa, y por tanto no tienen por qué ser llamadas explícitamente por el programador. Sus principales cometidos son:

• liberar los recursos computacionales que el objeto de dicha clase haya adquirido en su tiempo de ejecución al expirar éste.
• quitar los vínculos que pudiesen tener otros recursos u objetos con éste.

Los destructores son invocados automáticamente al alcanzar el flujo del programa el fin del ámbito en el que está declarado el objeto.

El uso de destructores es clave en el concepto de Adquirir Recursos es Inicializar.

ejemplo:

#include <iostream>
#include <cstring>
using namespace std;
 
class cadena {
  public:
   cadena();        // Constructor por defecto
   cadena(const char *c); // Constructor desde cadena c
   cadena(int n);   // Constructor de cadena de n caracteres
   cadena(const cadena &);   // Constructor copia
   ~cadena();       // Destructor

   void Asignar(const char *dest);
   char *Leer(char *c);
  private:
   char *cad;       // Puntero a char: cadena de caracteres
};
 
cadena::cadena() : cad(NULL) {}
 
cadena::cadena(const char *c) {
   cad = new char[strlen(c)+1];// Reserva memoria para cadena
   strcpy(cad, c);             // Almacena la cadena
}
 
cadena::cadena(int n) {
   cad = new char[n+1]; // Reserva memoria para n caracteres
   cad[0] = 0;          // Cadena vacía   
}
 
cadena::cadena(const cadena &Cad) {
   // Reservamos memoria para la nueva y la almacenamos
   cad = new char[strlen(Cad.cad)+1];
   // Reserva memoria para cadena
   strcpy(cad, Cad.cad);             // Almacena la cadena
} 
 
cadena::~cadena() {
   delete[] cad;        // Libera la memoria reservada a cad
}
 
void cadena::Asignar(const char *dest) {
   // Eliminamos la cadena actual:
   delete[] cad;
   // Reservamos memoria para la nueva y la almacenamos
   cad = new char[strlen(dest)+1]; 
   // Reserva memoria para la cadena
   strcpy(cad, dest);              // Almacena la cadena
}
 
char *cadena::Leer(char *c) {
   strcpy(c, cad);
   return c;
}

int main() {
   cadena Cadena1("Cadena de prueba");
   cadena Cadena2(Cadena1);   // Cadena2 es copia de Cadena1
   cadena *Cadena3;           // Cadena3 es un puntero
   char c[256];
   
   // Modificamos Cadena1:
   Cadena1.Asignar("Otra cadena diferente"); 
   // Creamos Cadena3:
   Cadena3 = new cadena("Cadena de prueba nº 3");
   
   // Ver resultados
   cout << "Cadena 1: " << Cadena1.Leer(c) << endl;
   cout << "Cadena 2: " << Cadena2.Leer(c) << endl;
   cout << "Cadena 3: " << Cadena3->Leer(c) << endl;
   
   delete Cadena3;  // Destruir Cadena3. 
   // Cadena1 y Cadena2 se destruyen automáticamente

   return 0;
}