¿Qué es el constructor y para qué sirve en C++?

Ingeniería en comunicaciones y electrónica
Tema 2.2.2 del Plan de Estudios de POO IPN

¡Hey, STEAMdiantes! ahora que ya conocen un poco más sobre la POO, sabemos que las clases son los planos y los objetos son las construcciones que creas a partir de esos planos. Pero ¿cómo se inicia la construcción? ¿quién pone los “cimientos” de un objeto y se asegura de que esté listo para usarse desde el primer momento? La respuesta es el constructor.

Un constructor en C++ es una función miembro especial que se llama automáticamente en el momento exacto en que se crea un objeto de una clase. Su principal misión es inicializar las variables miembro (los atributos) del objeto, garantizando que este nazca en un estado válido y predecible.

Piénsenlo como el protocolo de arranque de una máquina: antes de que pueda hacer cualquier trabajo, necesita cargar su configuración inicial. El constructor hace exactamente eso para tus objetos.

Características

Antes de ver el código, es crucial que identifiques un constructor por sus reglas únicas:

1. Mismo nombre que la clase: el constructor siempre, sin excepción, debe llamarse exactamente igual que la clase.
2. No tiene tipo de retorno: no retorna nada, ni siquiera void. Su trabajo no es devolver un valor, sino inicializar un objeto.

Tipos

Existen varios tipos de constructores, pero los tres más fundamentales que encontrarás en tu día a día son el constructor por defecto, el parametrizado y el de copia.

Constructor por defecto

Este es el constructor más básico. No acepta ningún argumento (parámetro). Si tú no escribes ningún constructor en tu clase, el compilador de C++ generará uno por ti. Este constructor por defecto generado por el compilador no hace nada, simplemente crea el objeto con sus miembros en un estado indeterminado (lo que se conoce como “basura” en memoria).

Por eso, es una excelente práctica definir tu propio constructor por defecto para asegurar una inicialización controlada. Veamos un ejemplo de un constructor por defecto:

#include <iostream>
#include <string>

class Jugador {
public:
    std::string nombre;
    int nivel;
    int vida;

    // Nuestro propio constructor por defecto
    Jugador() {
        nombre = "Héroe Anónimo";
        nivel = 1;
        vida = 100;
        std::cout << "Se ha creado un nuevo personaje con la configuración por defecto." << std::endl;
    }

    void mostrarInfo() {
        std::cout << "Nombre: " << nombre << " | Nivel: " << nivel << " | Vida: " << vida << "%" << std::endl;
    }
};

int main() {
    // Al crear el objeto 'jugador1', se llama automáticamente al constructor por defecto.
    Jugador jugador1;
    jugador1.mostrarInfo();

    return 0;
}

Al ejecutar este código, verás que jugador1 nace con los valores que establecimos, sin necesidad de asignarlos uno por uno después de su creación.

Constructor parametrizado

Este es el tipo de constructor más común y flexible. Te permite pasar valores (argumentos) en el momento de la creación del objeto para inicializar sus miembros con datos específicos. Puedes tener varios constructores parametrizados siempre que su lista de parámetros sea diferente (esto se conoce como sobrecarga de constructores).

Veamos un ejemplo del constructor parametrizado:

#include <iostream>
#include <string>

class Coche {
public:
    std::string marca;
    std::string modelo;
    int anio;

    // Un constructor parametrizado
    Coche(std::string m, std::string mod, int a) {
        marca = m;
        modelo = mod;
        anio = a;
        std::cout << "¡Constructor parametrizado en acción!" << std::endl;
    }

    void mostrarDetalles() {
        std::cout << "Coche: " << anio << " " << marca << " " << modelo << std::endl;
    }
};

int main() {
    // Pasamos los argumentos directamente al crear los objetos
    Coche miCoche("Nissan", "Versa", 2023);
    Coche cocheDeMiAmigo("Ford", "Mustang", 1968);

    miCoche.mostrarDetalles();
    cocheDeMiAmigo.mostrarDetalles();

    return 0;
}

Este método es mucho más directo y limpio que crear un objeto vacío y luego llamar a funciones set para cada atributo.

Constructor de copia

Este constructor, como su nombre indica, se utiliza para crear un nuevo objeto como una copia exacta de un objeto ya existente de la misma clase. Se llama automáticamente en situaciones como:

• Cuando inicializas un objeto a partir de otro: Coche coche2 = coche1;
• Cuando pasas un objeto por valor a una función.
• Cuando una función retorna un objeto por valor.

Si no defines uno, el compilador también crea un constructor de copia por defecto que realiza una copia miembro a miembro. Para la mayoría de los casos, esto es suficiente. Sin embargo, cuando trabajas con memoria dinámica (punteros), es fundamental que escribas tu propio constructor de copia para evitar problemas.

Veamos un ejemplo del constructor de copia:

#include <iostream>
#include <string>

class Mascota {
public:
    std::string nombre;
    int edad;

    Mascota(std::string n, int e) : nombre(n), edad(e) {} // Constructor parametrizado

    // Declaración explícita del constructor de copia
    Mascota(const Mascota &otraMascota) {
        nombre = otraMascota.nombre;
        edad = otraMascota.edad;
        std::cout << "¡Constructor de copia invocado para " << nombre << "!" << std::endl;
    }
};

int main() {
    Mascota perro1("Fido", 3);
    
    // Aquí se llama al constructor de copia
    Mascota perro2 = perro1; 
    
    std::cout << "Perro 1: " << perro1.nombre << std::endl;
    std::cout << "Perro 2: " << perro2.nombre << std::endl;

    return 0;
}

El constructor es una pieza muy importante en la POO en C++. Es la garantía de que tus objetos nacerán de una manera controlada, consistente y válida. Entender cómo y cuándo usar el constructor por defecto, el parametrizado y el de copia les va a permitir un control mucho más robusto sobre el ciclo de vida de sus objetos y les permitirá escribir código más seguro y profesional.

Gracias por leernos.
Si te gusto este artículo, únete a nuestra comunidad en Facebook o WhatsApp para más…
¡Hasta la próxima!