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 al que se puede llamar sin argumentos. Inicializa un objeto cuando no se proporcionan valores iniciales. Toda clase necesita una forma de crear objetos en un estado predeterminado válido.

Si no defines ningún constructor, el compilador genera un constructor predeterminado implícito que no hace nada para los tipos primitivos y llama a los constructores predeterminados de 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 deja de generar 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 el C++ moderno, puedes solicitar explícitamente el constructor predeterminado 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

Construyamos un sistema de contador sencillo que demuestre cómo los constructores predeterminados inicializan los objetos en un estado inicial válido.

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

Counter.h: Define una clase Counter que realiza un seguimiento de un valor de conteo. Tu clase debe tener:
- Un atributo privado count (entero)
- Un atributo privado name (cadena) para identificar el contador
- Un constructor predeterminado que inicializa count en 0 y name en "Unnamed", y después imprime "Counter created: <name>"
- Un método increment() que aumenta el conteo en 1
- Un método getCount() que devuelve el conteo actual
- Un método getName() que devuelve el nombre del contador
main.cpp: Demuestra que los constructores predeterminados funcionan al crear objetos de distintas formas. Lee un número de la entrada que indique cuántas veces incrementar el contador y después:
- Crea un Counter mediante inicialización directa: Counter c1;
- Crea otro Counter mediante inicialización con 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 deben comenzar en 0 gracias a tu constructor predeterminado, pero solo c1 se incrementará. Esto muestra cómo los constructores predeterminados garantizan que cada objeto comience en un estado predecible y válido, independientemente de cómo se cree.

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

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