Constructor por defecto

Parte de la sección Programación Orientada a Objetos del Journey de C++ de Coddy — lección 18 de 104.

Un constructor predeterminado es un constructor que se puede llamar sin argumentos. Inicializa un objeto cuando no se proporcionan valores iniciales. Cada clase necesita una forma de crear objetos en un estado predeterminado válido.

Si no defines ningún constructor, el compilador genera un constructor por defecto implícito que no hace nada para los tipos primitivos y llama a los constructores por defecto para los objetos miembro.

class Player {
    int health;
    int score;
public:
    Player() {           // Constructor por defecto
        health = 100;
        score = 0;
    }
};

Player p1;               // Llama al constructor por defecto
Player p2{};             // También llama al constructor por defecto

Una vez que defines cualquier constructor (como uno parametrizado), el compilador ya no genera un constructor predeterminado. Debes definir uno explícitamente si aún lo necesitas.

class Enemy {
    int damage;
public:
    Enemy(int d) : damage(d) {}  // Solo constructor parametrizado
};

Enemy e1(10);    // Funciona
Enemy e2;        // ¡Error! No hay constructor por defecto

En C++ moderno, puedes solicitar explícitamente el constructor por defecto generado por el compilador usando = default:

class Item {
    int id;
public:
    Item() = default;           // El compilador genera el constructor por defecto
    Item(int i) : id(i) {}
};

Los constructores por defecto son esenciales para crear arreglos de objetos y para clases utilizadas en contenedores como std::vector, que pueden necesitar construir elementos sin argumentos.

Desafío

Fácil

Vamos a construir un sistema de contador simple que demuestre cómo los constructores por defecto inicializan objetos a un estado inicial válido.

Crearás dos archivos para organizar tu código:

Counter.h: Define una clase Counter que rastree un valor de conteo. Tu clase debe tener:
- Un atributo privado count (entero)
- Un atributo privado name (string) para identificar el contador
- Un constructor por defecto que inicialice count a 0 y name a "Unnamed", y luego imprima "Counter created: <name>"
- Un método increment() que aumente el conteo en 1
- Un método getCount() que devuelva el conteo actual
- Un método getName() que devuelva el nombre del contador
main.cpp: Demuestra que los constructores por defecto funcionan al crear objetos de diferentes maneras. Lee un número de la entrada que indique cuántas veces se debe incrementar el contador, luego:
- Crea un Counter usando inicialización directa: Counter c1;
- Crea otro Counter usando inicialización por llaves: Counter c2{};
- Incrementa c1 el número de veces especificado por la entrada
- Imprime "<name>: <count>" para c1
- Imprime "<name>: <count>" para c2

Ambos contadores deberían comenzar en 0 gracias a tu constructor por defecto, pero solo c1 será incrementado. Esto muestra cómo los constructores por defecto aseguran que cada objeto comience en un estado predecible y válido, independientemente de cómo se cree.

Incluye tu archivo de cabecera en main.cpp usando #include "Counter.h".

Hoja de referencia

Un constructor por defecto es un constructor que se puede llamar sin argumentos. Inicializa un objeto cuando no se proporcionan valores iniciales.

class Player {
    int health;
    int score;
public:
    Player() {           // Default constructor
        health = 100;
        score = 0;
    }
};

Player p1;               // Calls default constructor
Player p2{};             // Also calls default constructor

Si no defines ningún constructor, el compilador genera un constructor por defecto implícito. Sin embargo, una vez que defines cualquier constructor (como uno parametrizado), el compilador ya no genera un constructor por defecto automáticamente.

class Enemy {
    int damage;
public:
    Enemy(int d) : damage(d) {}  // Parameterized constructor only
};

Enemy e1(10);    // Works
Enemy e2;        // Error! No default constructor

Puedes solicitar explícitamente el constructor por defecto generado por el compilador usando = default:

class Item {
    int id;
public:
    Item() = default;           // Compiler generates default constructor
    Item(int i) : id(i) {}
};

Los constructores por defecto son esenciales para crear arreglos de objetos y para clases utilizadas en contenedores como std::vector.

Pruébalo tú mismo

#include <iostream>
#include "Counter.h"

using namespace std;

int main() {
    // Lee el número de veces a incrementar
    int n;
    cin >> n;

    // TODO: Crea un Counter usando inicialización directa: Counter c1;

    // TODO: Crea otro Counter usando inicialización por llaves: Counter c2{};

    // TODO: Incrementa c1 el número de veces especificado por n

    // TODO: Imprime "<name>: <count>" para c1

    // TODO: Imprime "<name>: <count>" para c2

    return 0;
}