Summary  
This chapter covers using initialization lists in constructors to directly initialize member variables, ensuring efficient and correct setup, especially for const and reference members.

General domain of usage  
Object-oriented programming

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

class Transaction {
public:
    Transaction(float amount, float rate)
        : amount(amount), rate(rate), total(amount * rate) {}

    float processTransaction(float feePercent, float targetRate);

    float amount;
    float rate;
    float total;
};

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

TEST_CASE("Convert 100 at rate 1.2 with 5% fee and targetRate 0.8 -> 91.2", "[Transaction]") {
    Transaction t(100.0f, 1.2f);
    float result = t.processTransaction(5.0f, 0.8f);
    REQUIRE(result == Approx(91.2f));
}

TEST_CASE("Convert 50 at rate 0.9 with 10% fee and targetRate 1.1 -> 44.55", "[Transaction]") {
    Transaction t(50.0f, 0.9f);
    float result = t.processTransaction(10.0f, 1.1f);
    REQUIRE(result == Approx(44.55f));
}

TEST_CASE("Convert 200 at rate 1.5 with 0% fee and targetRate 0.5 -> 150.0", "[Transaction]") {
    Transaction t(200.0f, 1.5f);
    float result = t.processTransaction(0.0f, 0.5f);
    REQUIRE(result == Approx(150.0f));
}

TEST_CASE("Convert 100 at rate 2.0 with 100% fee and targetRate 1.5 -> 0.0", "[Transaction]") {
    Transaction t(100.0f, 2.0f);
    float result = t.processTransaction(100.0f, 1.5f);
    REQUIRE(result == Approx(0.0f));
}

TEST_CASE("Convert 0 at rate 2.0 with 10% fee and targetRate 0.5 -> 0.0", "[Transaction]") {
    Transaction t(0.0f, 2.0f);
    float result = t.processTransaction(10.0f, 0.5f);
    REQUIRE(result == Approx(0.0f));
}


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: Oefening met Initialisatielijsten

Voorbeeld

Oplossing

Uitdaging: Oefening met Initialisatielijsten

Voorbeeld

Oplossing