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

La programmazione orientata agli oggetti (OOP) in C++ consente di sviluppare codice pulito, riutilizzabile e scalabile organizzando i programmi attorno a oggetti e classi. Imparerai a definire e utilizzare classi, creare costruttori e distruttori, e applicare l'incapsulamento per proteggere i dati. Argomenti come ereditarietà, polimorfismo, membri statici, controllo degli accessi e overload degli operatori ti aiuteranno a progettare strutture di codice flessibili ed efficienti.

Imparare a creare classi e oggetti, definire attributi e metodi, lavorare con membri statici e la parola chiave this. Acquisire una solida base su come gli oggetti interagiscono e su come scrivere codice pulito e modulare utilizzando i principi della OOP.

Scopri come i costruttori e i distruttori gestiscono la creazione e la distruzione degli oggetti. Esercitati nell'uso delle liste di inizializzazione, della delega dei costruttori e nella scrittura di codice pulito ed efficiente con una corretta gestione del ciclo di vita degli oggetti.

Scopri come l'incapsulamento, uno dei principi fondamentali della OOP, migliora la modularità e la manutenibilità del codice attraverso la protezione dei dati, il controllo degli accessi e l'utilizzo di metodi accessor e mutator.

Scopri il meccanismo fondamentale della programmazione orientata agli oggetti che consente il riutilizzo del codice e favorisce la creazione di relazioni gerarchiche tra le classi.

Il polimorfismo è un concetto fondamentale nella programmazione orientata agli oggetti che consente la creazione di strutture di codice flessibili ed estensibili. Verranno trattati i concetti di funzione virtuale, classi astratte e sovraccarico degli operatori e il loro ruolo centrale nel favorire la flessibilità e la scalabilità del codice.

Sfida: Pratica con la Lista di Inizializzazione

Esempio

Soluzione

Sfida: Pratica con la Lista di Inizializzazione

Esempio

Soluzione