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

Objektorienterad programmering (OOP) i C++ hjälper dig att skapa ren, återanvändbar och skalbar kod genom att organisera program kring objekt och klasser. Du kommer att lära dig hur man definierar och använder klasser, skapar konstruktorer och destruktorer samt tillämpar inkapsling för att skydda data. Ämnen som arv, polymorfism, statiska medlemmar, åtkomstkontroll och operatoröverlagring hjälper dig att utforma flexibla och effektiva kodstrukturer.

Lär dig att skapa klasser och objekt, definiera attribut och metoder, arbeta med statiska medlemmar och nyckelordet this. Få en solid grund i hur objekt interagerar och hur man skriver ren, modulär kod med hjälp av OOP-principer.

Lär dig hur konstruktorer och destruktorer hanterar skapande och borttagning av objekt. Öva på att använda initialiseringslistor, konstruktordelegation och att skriva ren, effektiv kod med korrekt hantering av objektets livscykel.

Lär dig hur inkapsling, en av OOP:s grundprinciper, förbättrar kodens modularitet och underhållbarhet genom data-döljande, åtkomstkontroll och användning av accessor- och mutatormetoder.

Lär dig om den grundläggande mekanismen inom objektorienterad programmering som möjliggör återanvändning av kod och främjar skapandet av hierarkiska relationer mellan klasser.

Polymorfism är ett grundläggande koncept inom OOP som möjliggör skapandet av flexibla och utbyggbara kodstrukturer. Du kommer att lära dig om virtuella funktioner, abstrakta klasser och operatoröverlagring samt deras avgörande roller för att främja kodens flexibilitet och skalbarhet.

Challenge: Övning med Initialiseringslista

Lösning