Listas de Inicialização do Construtor

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

Você viu a sintaxe de dois-pontos em lições anteriores, como Player(std::string n, int h) : name(n), health(h) {}. Isso é chamado de lista de inicialização de membros e é a forma preferida de inicializar membros em C++.

A lista de inicializadores aparece após a lista de parâmetros do construtor, começando com dois-pontos. Cada membro é inicializado diretamente com seu valor, separado por vírgulas:

class Rectangle {
    int width;
    int height;
    const int id;
    int& reference;
public:
    Rectangle(int w, int h, int i, int& r) 
        : width(w), height(h), id(i), reference(r) {
        // Corpo do construtor (pode estar vazio)
    }
};

Por que usar listas de inicialização em vez de atribuição no corpo do construtor? Com a atribuição, os membros são primeiro construídos com seus valores padrão e, em seguida, recebem novos valores. Com as listas de inicialização, os membros são construídos diretamente com os valores corretos — isso é mais eficiente e, às vezes, obrigatório.

Certos membros devem ser inicializados usando a lista:

membros const — não podem receber atribuição após a construção

Membros de referência - devem ser vinculados na inicialização

Membros sem construtores padrão

class Player {
    const int maxHealth;    // Deve usar lista de inicializadores
    std::string name;
public:
    // Isso funciona
    Player(int max, std::string n) : maxHealth(max), name(n) {}
    
    // Isso NÃO compilaria:
    // Player(int max) { maxHealth = max; }  // Erro!
};

Os membros são inicializados na ordem em que são declarados na classe, não na ordem da lista de inicialização. Sempre escreva sua lista de inicialização na ordem das declarações para evitar confusão.

Desafio

Fácil

Vamos criar um sistema de configuração para um mecanismo de jogo que demonstra quando e por que as listas de inicializadores de membros são essenciais. Você criará uma classe GameConfig com membros que devem ser inicializados usando a sintaxe de lista de inicializadores.

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

GameConfig.h: defina uma classe GameConfig que armazene as configurações do jogo. Sua classe deve ter:
- Uma const std::string gameName: o título do jogo, que não pode ser alterado após a criação
- Uma const int maxPlayers: a quantidade máxima de jogadores, definida na construção
- Uma int& difficultyRef: uma referência a uma configuração de dificuldade externa
- Um int screenWidth e um int screenHeight: membros comuns para as configurações de exibição
- Um construtor que receba todos os parâmetros necessários e inicialize cada membro usando a lista de inicializadores. A lista de inicializadores deve seguir a ordem em que os membros são declarados na classe
- Um método display() que imprima a configuração neste formato:
```
Game: <gameName>
Max Players: <maxPlayers>
Difficulty: <difficultyRef value>
Resolution: <screenWidth>x<screenHeight>
```
main.cpp: leia os valores de configuração da entrada e crie um objeto GameConfig. Você precisará:
- Ler o nome do jogo (string), o número máximo de jogadores (int), a dificuldade (int), a largura (int) e a altura (int) da entrada: cada um em uma linha separada
- Criar uma variável local int para a dificuldade à qual a configuração fará referência
- Criar um objeto GameConfig usando o construtor com lista de inicializadores
- Chamar display() para exibir a configuração inicial
- Modificar diretamente a variável de dificuldade (multiplicá-la por 2)
- Imprimir "After difficulty change:"
- Chamar display() novamente para mostrar que a referência reflete o valor atualizado

Este desafio destaca por que as listas de inicializadores são importantes: seus membros const e o membro de referência não podem receber atribuições no corpo do construtor. Eles devem ser inicializados na lista. O membro de referência também demonstra como as alterações na variável original são refletidas através do objeto de configuração.

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

Experimente você mesmo

#include <iostream>
#include <string>
#include "GameConfig.h"

using namespace std;

int main() {
    // Ler valores de entrada
    string gameName;
    getline(cin, gameName);
    
    int maxPlayers;
    cin >> maxPlayers;
    
    int difficulty;
    cin >> difficulty;
    
    int width;
    cin >> width;
    
    int height;
    cin >> height;
    
    // TODO: Crie um objeto GameConfig usando o construtor de lista de inicializadores
    // O construtor deve receber: gameName, maxPlayers, difficulty (por referência), width, height
    
    // TODO: Chame display() para mostrar a configuração inicial
    
    // TODO: Modifique a variável difficulty diretamente (multiplique-a por 2)
    
    // TODO: Print "After difficulty change:"
    
    // TODO: Chame display() novamente para mostrar a configuração atualizada
    
    return 0;
}