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

Objektorientierte Programmierung (OOP) in C++ ermöglicht es, sauberen, wiederverwendbaren und skalierbaren Code zu erstellen, indem Programme um Objekte und Klassen organisiert werden. Sie lernen, wie man Klassen definiert und verwendet, Konstruktoren und Destruktoren erstellt und Kapselung anwendet, um Daten zu schützen. Themen wie Vererbung, Polymorphismus, statische Mitglieder, Zugriffskontrolle und Operatorüberladung unterstützen Sie beim Entwurf flexibler und effizienter Code-Strukturen.

Erlernen der Erstellung von Klassen und Objekten, Definition von Attributen und Methoden, Arbeit mit statischen Mitgliedern und dem this-Schlüsselwort. Solide Grundlagen darüber, wie Objekte interagieren und wie sauberer, modularer Code unter Verwendung von OOP-Prinzipien geschrieben wird.

Erfahren Sie, wie Konstruktoren und Destruktoren die Objekterstellung und -bereinigung steuern. Üben Sie den Einsatz von Initialisierungsliste, Konstruktor-Delegation und das Schreiben von sauberem, effizientem Code mit korrekter Verwaltung des Objektlebenszyklus.

Erfahren Sie, wie die Kapselung als eines der zentralen Prinzipien der OOP die Modularität und Wartbarkeit von Code durch Datenverbergung, Zugriffskontrolle sowie die Verwendung von Zugriffsmethoden und Änderungsmethoden verbessert.

Erfahren Sie mehr über den grundlegenden Mechanismus der objektorientierten Programmierung, der die Wiederverwendung von Code ermöglicht und die Schaffung hierarchischer Beziehungen zwischen Klassen fördert.

Polymorphismus ist ein grundlegendes Konzept der OOP, das die Erstellung flexibler und erweiterbarer Code-Strukturen ermöglicht. Sie lernen virtuelle Funktionen, abstrakte Klassen und Operatorüberladung sowie deren zentrale Bedeutung für die Förderung von Flexibilität und Skalierbarkeit des Codes kennen.

Herausforderung: Übung Zur Initialisierungsliste

Beispiel

Lösung

Herausforderung: Übung Zur Initialisierungsliste

Beispiel

Lösung