Summary
This chapter covers how constructors initialize object state and allocate resources when an object is created, and how destructors release resources and perform cleanup when an object’s lifetime ends.

General domain of usage
Resource management in object-oriented programming

#define CATCH_CONFIG_MAIN
#include <catch2/catch.hpp>
#include <sstream>
#include <iostream>

class GradesManager {
public:
    GradesManager(int size);

    double calculateAverage();

    ~GradesManager();

private:
    int* grades;
    int size;
};

// ------------------- Tests -------------------

TEST_CASE("Average grade for size 5 should be 3", "[GradesManager]") {
    GradesManager manager(5); // grades: 1,2,3,4,5
    double avg = manager.calculateAverage();
    REQUIRE(avg == Approx(3.0));
}

TEST_CASE("Average grade for size 1 should be 1", "[GradesManager]") {
    GradesManager manager(1); // grades: 1
    double avg = manager.calculateAverage();
    REQUIRE(avg == Approx(1.0));
}

TEST_CASE("Average grade for size 10 should be 5.5", "[GradesManager]") {
    GradesManager manager(10); // grades: 1..10
    double avg = manager.calculateAverage();
    REQUIRE(avg == Approx(5.5));
}

TEST_CASE("Constructor output should print 'Grades initialized.'", "[GradesManager][output]") {
    std::ostringstream oss;
    std::streambuf* oldCout = std::cout.rdbuf(oss.rdbuf());

    GradesManager manager(3);

    std::cout.rdbuf(oldCout);
    REQUIRE(oss.str().find("Grades initialized.") != std::string::npos);
}

TEST_CASE("Destructor output should print 'Grades memory released.'", "[GradesManager][output]") {
    std::ostringstream oss;
    std::streambuf* oldCout = std::cout.rdbuf(oss.rdbuf());

    {
        GradesManager manager(2);
    } // destructor called here

    std::cout.rdbuf(oldCout);
    REQUIRE(oss.str().find("Grades memory released.") != std::string::npos);
}

test.cpp

A Programação Orientada a Objetos (POO) em C++ auxilia na construção de códigos limpos, reutilizáveis e escaláveis ao organizar programas em torno de objetos e classes. Você aprenderá a definir e utilizar classes, criar construtores e destrutores, além de aplicar encapsulamento para proteger dados. Tópicos como herança, polimorfismo, membros estáticos, controle de acesso e sobrecarga de operadores ajudarão a projetar estruturas de código flexíveis e eficientes.

Aprenda a criar classes e objetos, definir atributos e métodos, trabalhar com membros estáticos e a palavra-chave this. Adquira uma base sólida sobre como os objetos interagem e como escrever código limpo e modular utilizando os princípios da POO.

Aprenda como construtores e destrutores gerenciam a criação e a destruição de objetos. Prática com listas de inicialização, delegação de construtores e escrita de código limpo e eficiente com manipulação adequada do ciclo de vida dos objetos.

Aprenda como a encapsulação, um dos princípios fundamentais da POO, melhora a modularidade e a manutenibilidade do código por meio do ocultamento de dados, controle de acesso e uso de métodos acessores e mutadores.

Aprenda sobre o mecanismo fundamental da programação orientada a objetos que possibilita o reuso de código e promove a criação de relacionamentos hierárquicos entre classes.

Polimorfismo é um conceito fundamental em POO que permite a criação de estruturas de código flexíveis e extensíveis. Você aprenderá sobre função virtual, classes abstratas e sobrecarga de operadores e seus papéis essenciais na promoção da flexibilidade e escalabilidade do código.

Desafio: Gerenciamento de Dados com Construtores e Destrutores

Solução