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

Objectgeoriënteerd programmeren (OOP) in C++ helpt bij het schrijven van schone, herbruikbare en schaalbare code door programma's te organiseren rond objecten en klassen. Je leert hoe je klassen definieert en gebruikt, constructors en destructors aanmaakt, en encapsulatie toepast om data te beschermen. Onderwerpen zoals overerving, polymorfisme, statische leden, toegangscontrole en operator overloading helpen bij het ontwerpen van flexibele en efficiënte code-structuren.

Leer hoe je klassen en objecten maakt, attributen en methoden definieert, werkt met statische leden en het this-keyword gebruikt. Verkrijg een solide basis in hoe objecten met elkaar omgaan en hoe je schone, modulaire code schrijft met behulp van OOP-principes.

Leer hoe constructors en destructors het aanmaken en opruimen van objecten beheren. Oefen met het gebruik van initialisatielijsten, constructor-delegatie en het schrijven van schone, efficiënte code met correcte afhandeling van de levenscyclus van objecten.

Leer hoe encapsulatie, een van de kernprincipes van OOP, de modulariteit en onderhoudbaarheid van code verbetert door gegevensafscherming, toegangscontrole en het gebruik van accessor- en mutatormethoden.

Leer over het fundamentele mechanisme van objectgeoriënteerd programmeren dat codehergebruik mogelijk maakt en het creëren van hiërarchische relaties tussen klassen bevordert.

Polymorfisme is een fundamenteel concept in OOP dat het mogelijk maakt om flexibele en uitbreidbare code-structuren te creëren. U leert over virtuele functies, abstracte klassen en operator-overloading en hun cruciale rol in het bevorderen van codeflexibiliteit en schaalbaarheid.

Uitdaging: Gegevensbeheer met Constructors en Destructors

Oplossing