Da trilha de C++ Este conceito ainda não saiu como card do dia. ir para o card de hoje

C++ POO Básico

Construtores e destrutores

Em C++, construtores e destrutores são funções especiais que gerenciam o ciclo de vida dos objetos. O construtor é chamado automaticamente quando um objeto é criado e inicializa seus membros. O destrutor é chamado quando o objeto é destruído e libera recursos.

A lista de inicialização é a forma idiomática de inicializar membros no construtor. Ela é obrigatória para membros const, referências e objetos sem construtor padrão. Além disso, evita inicialização seguida de atribuição.

O construtor padrão é aquele que pode ser chamado sem argumentos. Se nenhum construtor for declarado, o compilador gera um implicitamente. Já a palavra-chave explicit impede conversões implícitas indesejadas em construtores de um argumento.

Neste card, você verá como definir construtores, usar a lista de inicialização, criar destrutores e aplicar explicit para evitar conversões acidentais.

Pontos-chave

  • Construtores inicializam objetos; destrutores liberam recursos.
  • Use a lista de inicialização para inicializar membros de forma eficiente e obrigatória em alguns casos.
  • O construtor padrão pode ser gerado pelo compilador se nenhum outro for declarado.
  • explicit evita conversões implícitas em construtores de um argumento.
  • O destrutor não recebe argumentos e não retorna valor.
construtores_destructores.cpp
#include <iostream>
#include <string>

class Recurso {
public:
    // Construtor padrão
    Recurso() : nome_("padrao"), valor_(0) {
        std::cout << "Construtor padrao: " << nome_ << "\n";
    }

    // Construtor com lista de inicialização
    explicit Recurso(const std::string& nome, int valor = 0)
        : nome_(nome), valor_(valor) {
        std::cout << "Construtor: " << nome_ << " = " << valor_ << "\n";
    }

    // Destrutor
    ~Recurso() {
        std::cout << "Destrutor: " << nome_ << "\n";
    }

    void mostrar() const {
        std::cout << nome_ << ": " << valor_ << "\n";
    }

private:
    std::string nome_;
    int valor_;
};

int main() {
    Recurso r1;                    // chama construtor padrão
    Recurso r2("teste", 42);       // chama construtor com argumentos
    r1.mostrar();
    r2.mostrar();

    // Recurso r3 = "invalido";    // erro: construtor é explicit
    Recurso r3 = Recurso("copia"); // ok: construção explícita
    r3.mostrar();

    return 0;
}

Exercícios

  1. 1
    Fácil

    Construtor e destrutor simples

    Crie uma classe Pessoa com os atributos nome (string) e idade (int). Implemente um construtor que recebe esses valores usando lista de inicialização e um destrutor que imprime uma mensagem. No main, crie um objeto e mostre seus dados.

    Resolver
  2. 2
    Médio

    Construtor padrão e explicit

    Crie uma classe Contador que mantém um valor inteiro. Ela deve ter:

    • Um construtor padrão que inicializa o contador com 0.
    • Um construtor explicit que recebe um valor inicial inteiro.
    • Um destrutor que não faz nada (ou apenas imprime uma mensagem).
    • Um método incrementar() que soma 1.
    • Um método getValor() que retorna o valor.

    No main, crie um Contador padrão, incremente duas vezes e mostre o valor. Depois crie um Contador com valor inicial 10 usando construção explícita e mostre o valor.

    Resolver
  3. 3
    Desafio

    Gerenciamento de recurso com construtor e destrutor

    Implemente uma classe Buffer que gerencia um array dinâmico de inteiros. Ela deve:

    • Ter um construtor padrão que cria um buffer vazio (tamanho 0).
    • Ter um construtor explicit que recebe um tamanho e aloca memória dinamicamente.
    • Ter um destrutor que libera a memória alocada.
    • Ter um método set(int indice, int valor) que define um valor em uma posição.
    • Ter um método get(int indice) const que retorna o valor em uma posição.
    • Ter um método tamanho() const que retorna o tamanho do buffer.

    No main, crie um Buffer com tamanho 5, preencha com valores de 0 a 4, mostre os valores e o tamanho. Depois crie um Buffer padrão e mostre seu tamanho.

    Resolver

Continue estudando