Construtor Padrão

Parte da seção Programação Orientada a Objetos do Journey de C++ da Coddy. Lição 18 de 104.

Um construtor padrão é um construtor que pode ser chamado sem argumentos. Ele inicializa um objeto quando nenhum valor inicial é fornecido. Toda classe precisa de uma maneira de criar objetos em um estado padrão válido.

Se você não definir nenhum construtor, o compilador gera um construtor padrão implícito que não faz nada para tipos primitivos e chama construtores padrão para objetos membros.

class Player {
    int health;
    int score;
public:
    Player() {           // Construtor padrão
        health = 100;
        score = 0;
    }
};

Player p1;               // Chama o construtor padrão
Player p2{};             // Também chama o construtor padrão

Uma vez que você define qualquer construtor (como um parametrizado), o compilador não gera mais um construtor padrão. Você deve definir um explicitamente se ainda precisar dele.

class Enemy {
    int damage;
public:
    Enemy(int d) : damage(d) {}  // Apenas construtor parametrizado
};

Enemy e1(10);    // Funciona
Enemy e2;        // Erro! Nenhum construtor padrão

No C++ moderno, você pode solicitar explicitamente o construtor padrão gerado pelo compilador usando = default:

class Item {
    int id;
public:
    Item() = default;           // O compilador gera o construtor padrão
    Item(int i) : id(i) {}
};

Construtores padrão são essenciais para criar arrays de objetos e para classes usadas em containers como std::vector, que podem precisar construir elementos sem argumentos.

Desafio

Fácil

Vamos criar um sistema simples de contador que demonstra como os construtores padrão inicializam objetos para um estado inicial válido.

Você criará dois arquivos para organizar seu código:

Counter.h: defina uma classe Counter que acompanhe um valor de contagem. Sua classe deve ter:
- Um atributo privado count (inteiro)
- Um atributo privado name (string) para identificar o contador
- Um construtor padrão que inicializa count com 0 e name com "Unnamed", então imprime "Counter created: <name>"
- Um método increment() que aumenta a contagem em 1
- Um método getCount() que retorna a contagem atual
- Um método getName() que retorna o nome do contador
main.cpp: demonstre que os construtores padrão funcionam ao criar objetos de diferentes maneiras. Leia um número da entrada indicando quantas vezes incrementar o contador e, então:
- Crie um Counter usando inicialização direta: Counter c1;
- Crie outro Counter usando inicialização com chaves: Counter c2{};
- Incremente c1 o número de vezes especificado pela entrada
- Imprima "<name>: <count>" para c1
- Imprima "<name>: <count>" para c2

Ambos os contadores devem começar em 0 graças ao seu construtor padrão, mas apenas c1 será incrementado. Isso mostra como os construtores padrão garantem que todo objeto comece em um estado previsível e válido, independentemente de como é criado.

Inclua seu arquivo de cabeçalho em main.cpp usando #include "Counter.h".

Experimente você mesmo

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

using namespace std;

int main() {
    // Lê o número de vezes para incrementar
    int n;
    cin >> n;

    // TODO: Crie um Counter usando inicialização direta: Counter c1;

    // TODO: Crie outro Counter usando inicialização por chaves: Counter c2{};

    // TODO: Incremente c1 o número de vezes especificado por n

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

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

    return 0;
}