El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
HOME Mis cursos Finalizados
◄ Anterior
◄

Constructores y Destructores

Siguiente ►
►

En este tema, aprenderemos sobre dos conceptos fundamentales en la Programación Orientada a Objetos (POO) en C++: los constructores y los destructores. Estos son métodos especiales que se utilizan para inicializar y limpiar objetos, respectivamente.

  1. Constructores

¿Qué es un Constructor?

Un constructor es una función miembro especial de una clase que se llama automáticamente cuando se crea un objeto de esa clase. Su principal función es inicializar los miembros de datos del objeto.

Características de los Constructores:

  • Nombre del Constructor: El constructor tiene el mismo nombre que la clase.
  • No tiene tipo de retorno: No devuelve ningún valor, ni siquiera void.
  • Llamada Automática: Se llama automáticamente cuando se crea un objeto.
  • Sobrecarga: Puede haber más de un constructor en una clase (sobrecarga de constructores).

Tipos de Constructores:

  1. Constructor por Defecto: No toma ningún argumento.
  2. Constructor Parametrizado: Toma uno o más argumentos.
  3. Constructor de Copia: Inicializa un objeto usando otro objeto de la misma clase.

Ejemplo de Constructores:

#include <iostream>
using namespace std;

class Punto {
private:
    int x, y;

public:
    // Constructor por defecto
    Punto() {
        x = 0;
        y = 0;
    }

    // Constructor parametrizado
    Punto(int xVal, int yVal) {
        x = xVal;
        y = yVal;
    }

    // Constructor de copia
    Punto(const Punto &p) {
        x = p.x;
        y = p.y;
    }

    void mostrar() {
        cout << "Punto(" << x << ", " << y << ")" << endl;
    }
};

int main() {
    Punto p1; // Llama al constructor por defecto
    Punto p2(5, 10); // Llama al constructor parametrizado
    Punto p3 = p2; // Llama al constructor de copia

    p1.mostrar();
    p2.mostrar();
    p3.mostrar();

    return 0;
}

Explicación del Código:

  • Constructor por Defecto: Punto() { x = 0; y = 0; } inicializa x y y a 0.
  • Constructor Parametrizado: Punto(int xVal, int yVal) { x = xVal; y = yVal; } inicializa x y y con los valores proporcionados.
  • Constructor de Copia: Punto(const Punto &p) { x = p.x; y = p.y; } inicializa x y y con los valores de otro objeto p.

  1. Destructores

¿Qué es un Destructor?

Un destructor es una función miembro especial de una clase que se llama automáticamente cuando un objeto de esa clase se destruye. Su principal función es liberar recursos que el objeto pudo haber adquirido durante su vida.

Características de los Destructores:

  • Nombre del Destructor: El destructor tiene el mismo nombre que la clase, pero precedido por una tilde (~).
  • No tiene tipo de retorno: No devuelve ningún valor, ni siquiera void.
  • No toma argumentos: No puede ser sobrecargado.
  • Llamada Automática: Se llama automáticamente cuando el objeto sale del ámbito o se elimina.

Ejemplo de Destructores:

#include <iostream>
using namespace std;

class Punto {
private:
    int x, y;

public:
    // Constructor por defecto
    Punto() {
        x = 0;
        y = 0;
        cout << "Constructor por defecto llamado" << endl;
    }

    // Constructor parametrizado
    Punto(int xVal, int yVal) {
        x = xVal;
        y = yVal;
        cout << "Constructor parametrizado llamado" << endl;
    }

    // Destructor
    ~Punto() {
        cout << "Destructor llamado para Punto(" << x << ", " << y << ")" << endl;
    }

    void mostrar() {
        cout << "Punto(" << x << ", " << y << ")" << endl;
    }
};

int main() {
    Punto p1; // Llama al constructor por defecto
    Punto p2(5, 10); // Llama al constructor parametrizado

    p1.mostrar();
    p2.mostrar();

    return 0;
}

Explicación del Código:

  • Destructor: ~Punto() { cout << "Destructor llamado para Punto(" << x << ", " << y << ")" << endl; } imprime un mensaje cuando el objeto se destruye.

Ejercicios Prácticos

Ejercicio 1: Constructor y Destructor Básico

Instrucciones:

  1. Crea una clase Rectangulo con dos miembros de datos ancho y alto.
  2. Implementa un constructor por defecto que inicialice ancho y alto a 1.
  3. Implementa un constructor parametrizado que inicialice ancho y alto con valores proporcionados.
  4. Implementa un destructor que imprima un mensaje cuando se llame.
  5. Crea objetos de Rectangulo en main y muestra sus valores.

Solución:

#include <iostream>
using namespace std;

class Rectangulo {
private:
    int ancho, alto;

public:
    // Constructor por defecto
    Rectangulo() {
        ancho = 1;
        alto = 1;
        cout << "Constructor por defecto llamado" << endl;
    }

    // Constructor parametrizado
    Rectangulo(int a, int h) {
        ancho = a;
        alto = h;
        cout << "Constructor parametrizado llamado" << endl;
    }

    // Destructor
    ~Rectangulo() {
        cout << "Destructor llamado para Rectangulo(" << ancho << ", " << alto << ")" << endl;
    }

    void mostrar() {
        cout << "Rectangulo(" << ancho << ", " << alto << ")" << endl;
    }
};

int main() {
    Rectangulo r1; // Llama al constructor por defecto
    Rectangulo r2(4, 5); // Llama al constructor parametrizado

    r1.mostrar();
    r2.mostrar();

    return 0;
}

Ejercicio 2: Constructor de Copia

Instrucciones:

  1. Añade un constructor de copia a la clase Rectangulo.
  2. Crea un objeto Rectangulo usando otro objeto existente.
  3. Muestra los valores del nuevo objeto para verificar que se ha copiado correctamente.

Solución:

#include <iostream>
using namespace std;

class Rectangulo {
private:
    int ancho, alto;

public:
    // Constructor por defecto
    Rectangulo() {
        ancho = 1;
        alto = 1;
        cout << "Constructor por defecto llamado" << endl;
    }

    // Constructor parametrizado
    Rectangulo(int a, int h) {
        ancho = a;
        alto = h;
        cout << "Constructor parametrizado llamado" << endl;
    }

    // Constructor de copia
    Rectangulo(const Rectangulo &r) {
        ancho = r.ancho;
        alto = r.alto;
        cout << "Constructor de copia llamado" << endl;
    }

    // Destructor
    ~Rectangulo() {
        cout << "Destructor llamado para Rectangulo(" << ancho << ", " << alto << ")" << endl;
    }

    void mostrar() {
        cout << "Rectangulo(" << ancho << ", " << alto << ")" << endl;
    }
};

int main() {
    Rectangulo r1(4, 5); // Llama al constructor parametrizado
    Rectangulo r2 = r1; // Llama al constructor de copia

    r1.mostrar();
    r2.mostrar();

    return 0;
}

Conclusión

En esta sección, hemos aprendido sobre los constructores y destructores en C++. Los constructores se utilizan para inicializar objetos, mientras que los destructores se utilizan para limpiar recursos cuando los objetos ya no son necesarios. Comprender estos conceptos es crucial para gestionar correctamente la memoria y los recursos en programas orientados a objetos.

En el próximo tema, exploraremos la herencia, un concepto fundamental en la Programación Orientada a Objetos que permite crear nuevas clases basadas en clases existentes.

◄ Anterior
◄
Siguiente ►
►
El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
© Copyright 2024. Todos los derechos reservados