Contructores y Destructores en C++

Contructores y Destructores en C++

Constructor

^

Los constructores son funciones miembro especiales que sirven para inicializar un objeto de una determinada clase al mismo tiempo que se declara.

Características

• Tienen el mismo nombre que la clase a la que pertenecen.
• No tienen tipo de retorno, y por lo tanto no retornan ningún valor.
• No pueden ser heredados.
• Por último, deben ser públicos, no tendría ningún sentido declarar un constructor como privado, ya que siempre se usan desde el exterior de la clase, ni tampoco como protegido, ya que no puede ser heredado.

Ejemplo

class <identificador de clase> {
    public:
        <identificador de clase>(<lista de parámetros>) [: <lista de constructores>] {
            <código del constructor>
        }
        ...
}

Añadamos un constructor a nuestra clase pareja:

#include <iostream> 
using namespace std;
 
class pareja {
   public:
      // Constructor
      pareja(int a2, int b2);
      // Funciones miembro de la clase "pareja"
      void Lee(int &a2, int &b2);
      void Guarda(int a2, int b2);
   private:
      // Datos miembro 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() {
   pareja par1(12, 32);
   int x, y;
   
   par1.Lee(x, y);
   cout << "Valor de par1.a: " << x << endl;
   cout << "Valor de par1.b: " << y << endl;
   
   return 0;
}

Destructores

Los destructores son funciones miembro especiales que sirven para eliminar un objeto de una determinada clase. El destructor realizará procesos necesarios cuando un objeto termine su ámbito temporal, por ejemplo liberando la memoria dinámica utilizada por dicho objeto o liberando recursos usados, como ficheros, dispositivos, etc.

Características

• También tienen el mismo nombre que la clase a la que pertenecen, pero tienen el símbolo ˜ delante.
• No tienen tipo de retorno, y por lo tanto no retornan ningún valor.
• No tienen parámetros.
• No pueden ser heredados.
• Deben ser públicos, no tendría ningún sentido declarar un destructor como privado, ya que siempre se usan desde el exterior de la clase, ni tampoco como protegido, ya que no puede ser heredado.
• No pueden ser sobrecargados, lo cual es lógico, puesto que no tienen valor de retorno ni parámetros, no hay posibilidad de sobrecarga.

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;
}