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 ontwikkelen van overzichtelijke, herbruikbare en schaalbare code door programma's te structureren rond objecten en klassen. U leert hoe u 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 ondersteunen het ontwerpen van flexibele en efficiënte code-structuren.

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

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

Leer hoe encapsulatie, een van de kernprincipes van OOP, de modulariteit en het onderhoud 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-overbelasting en hun cruciale rol bij het bevorderen van codeflexibiliteit en schaalbaarheid.

Uitdaging: Gegevensbeheer met Constructors en Destructors

Voorbeeld

Oplossing

Uitdaging: Gegevensbeheer met Constructors en Destructors

Voorbeeld

Oplossing