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

Olio-ohjelmointi (OOP) C++:ssa auttaa rakentamaan selkeää, uudelleenkäytettävää ja laajennettavaa koodia järjestämällä ohjelmat olioiden ja luokkien ympärille. Opit määrittelemään ja käyttämään luokkia, luomaan konstruktoreita ja destruktoreita sekä soveltamaan kapselointia tietojen suojaamiseksi. Aiheet kuten perintä, polymorfismi, staattiset jäsenet, pääsynhallinta ja operaattorien ylikuormitus auttavat suunnittelemaan joustavia ja tehokkaita koodirakenteita.

Opi luomaan luokkia ja olioita, määrittelemään attribuutteja ja metodeja, työskentelemään staattisten jäsenten ja this-avainsanan kanssa. Hanki vankka perusta olioiden vuorovaikutuksesta sekä puhtaan, modulaarisen koodin kirjoittamisesta OOP-periaatteiden mukaisesti.

Opi, kuinka konstruktorit ja destruktorit hallitsevat olioiden luomista ja siivoamista. Harjoittele alustamislistojen käyttöä, konstruktorin delegointia sekä kirjoita selkeää ja tehokasta koodia oikealla olion elinkaaren hallinnalla.

Opi, kuinka kapselointi, yksi olio-ohjelmoinnin (OOP) keskeisistä periaatteista, parantaa koodin modulaarisuutta ja ylläpidettävyyttä tietojen piilottamisen, pääsynhallinnan sekä aksessorien ja mutaattorien käytön avulla.

Opi olio-ohjelmoinnin perustavanlaatuisesta mekanismista, joka mahdollistaa koodin uudelleenkäytön ja edistää hierarkkisten suhteiden luomista luokkien välillä.

Polymorfismi on olennainen käsite olio-ohjelmoinnissa, joka mahdollistaa joustavien ja laajennettavien koodirakenteiden luomisen. Opit virtuaalifunktioista, abstrakteista luokista ja operaattorien ylikuormituksesta sekä niiden keskeisestä roolista koodin joustavuuden ja skaalautuvuuden edistämisessä.

Haaste: Tietojen Hallinta Konstruktoreilla ja Destruktoreilla

Ratkaisu