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 construir um sistema de contador simples que demonstra como os construtores padrão inicializam objetos em um estado inicial válido.

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

Counter.h: Defina uma classe Counter que rastreia 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 como 0 e name como "Unnamed", e 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, em seguida:
- Crie um Counter usando inicialização direta: Counter c1;
- Crie outro Counter usando inicialização por chaves (brace initialization): 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 cada objeto comece em um estado previsível e válido, independentemente de como ele é criado.

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

Folha de consulta

Um construtor padrão (default constructor) é um construtor que pode ser chamado sem argumentos. Ele inicializa um objeto quando nenhum valor inicial é fornecido.

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

Se você não definir nenhum construtor, o compilador gera um construtor padrão implícito. No entanto, uma vez que você define qualquer construtor (como um parametrizado), o compilador não gera mais um construtor padrão automaticamente.

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

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

Você pode solicitar explicitamente o construtor padrão gerado pelo compilador usando = default:

class Item {
    int id;
public:
    Item() = default;           // Compiler generates default constructor
    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.

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