Summary  
This chapter covers how to use access modifiers to control the visibility and accessibility of classes, methods, and properties in object-oriented programming.

General domain of usage  
Object-oriented software development.

#define CATCH_CONFIG_MAIN
#include <catch2/catch.hpp>
#include <sstream>
#include <iostream>
#include <string>

class DigitalWallet {
private:
    double balance;

protected:
    std::string owner;

public:
    DigitalWallet(const std::string& ownerName);

    void addMoney(double amount);

    void showBalance() const;
};

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

TEST_CASE("Add 100$ to Alice's wallet => balance should become 100 and prints correct message", "[DigitalWallet]") {
    DigitalWallet wallet("Alice");

    std::ostringstream oss;
    std::streambuf* oldCout = std::cout.rdbuf(oss.rdbuf());

    wallet.addMoney(100);

    std::cout.rdbuf(oldCout);
    std::string output = oss.str();

    REQUIRE(output.find("100$ added to Alice's wallet.") != std::string::npos);

    oss.str("");
    oss.clear();
    std::cout.rdbuf(oss.rdbuf());

    wallet.showBalance();

    std::cout.rdbuf(oldCout);
    output = oss.str();
    REQUIRE(output.find("Owner: Alice") != std::string::npos);
    REQUIRE(output.find("Balance: $100") != std::string::npos);
}

TEST_CASE("Add -50$ and 0$ to Bob's wallet => balance remains 0 and prints invalid amount messages", "[DigitalWallet]") {
    DigitalWallet wallet("Bob");

    std::ostringstream oss;
    std::streambuf* oldCout = std::cout.rdbuf(oss.rdbuf());

    wallet.addMoney(-50);
    wallet.addMoney(0);

    std::cout.rdbuf(oldCout);
    std::string output = oss.str();

    REQUIRE(output.find("Invalid amount!") != std::string::npos);

    oss.str("");
    oss.clear();
    std::cout.rdbuf(oss.rdbuf());

    wallet.showBalance();

    std::cout.rdbuf(oldCout);
    output = oss.str();
    REQUIRE(output.find("Owner: Bob") != std::string::npos);
    REQUIRE(output.find("Balance: $0") != std::string::npos);
}

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: Modificatori di Accesso

Soluzione