Summary  
This chapter covers how to define methods in a class—as functions that encapsulate object behaviors—and how to implement them either inside the class or externally using the scope resolution operator to separate declaration from implementation.

General domain of usage  
Automotive software development (e.g., modeling vehicle behaviors)

I metodi in una **classe** sono essenzialmente **funzioni definite all'interno della classe**. Vengono utilizzati per definire i comportamenti o le azioni che gli **oggetti** della **classe** possono eseguire.




I metodi spesso manipolano gli attributi della **classe** o eseguono operazioni rilevanti per gli **oggetti**.

### Implementazione dei metodi al di fuori della classe

I metodi possono essere definiti al di fuori della dichiarazione della `class` utilizzando l'**operatore di risoluzione dell'ambito** (`::`). Questo viene spesso fatto per separare la dichiarazione nel file header dalla sua implementazione nel file sorgente. Ecco come si procede:

Y2xhc3MgRXhhbXBsZSB7CnB1YmxpYzoKICAgIHZvaWQgTWV0aG9kKCk7Cn07

I2luY2x1ZGUgIkV4YW1wbGUuaCIKCnZvaWQgRXhhbXBsZTo6TWV0aG9kKCkKewogICAgc3RkOjpjb3V0IDw8ICJNZXRob2Qgd2FzIGNhbGxlZCIgPDwgc3RkOjplbmRsOwp9

**Non è obbligatorio creare due file distinti** per questo scopo; è possibile ottenere lo stesso risultato all'interno di un unico file e, in alcune situazioni, ciò risulta vantaggioso.

I2luY2x1ZGUgPGlvc3RyZWFtPgoKY2xhc3MgRXhhbXBsZSB7CnB1YmxpYzoKICAgIHZvaWQgTWV0aG9kKCk7Cn07Cgp2b2lkIEV4YW1wbGU6Ok1ldGhvZCgpIHsgc3RkOjpjb3V0IDw8ICJNZXRob2Qgd2FzIGNhbGxlZCIgPDwgc3RkOjplbmRsOyB9

Sentiti libero di affrontare il compito utilizzando il metodo che preferisci. Tuttavia, una buona pratica comune è **separare la dichiarazione dall'implementazione**.

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

class Product {
public:
    float price;
    float discount;

    float getFinalPrice();
};

TEST_CASE("Final price with discount <= 50", "[Product]") {
    Product item;
    item.price = 200.0f;
    item.discount = 30.0f; // 30% discount

    float finalPrice = item.getFinalPrice();
    REQUIRE(finalPrice == Approx(140.0f)); // 200 - 30% = 140
}

TEST_CASE("Final price with discount > 50 should cap at 50%", "[Product]") {
    Product item;
    item.price = 100.0f;
    item.discount = 60.0f; // > 50%, should cap

    float finalPrice = item.getFinalPrice();
    REQUIRE(finalPrice == Approx(50.0f)); // 100 - 50% = 50
}

TEST_CASE("Final price with 0% discount should equal original price", "[Product]") {
    Product item;
    item.price = 150.0f;
    item.discount = 0.0f;

    float finalPrice = item.getFinalPrice();
    REQUIRE(finalPrice == Approx(150.0f));
}

TEST_CASE("Final price with exactly 50% discount", "[Product]") {
    Product item;
    item.price = 80.0f;
    item.discount = 50.0f;

    float finalPrice = item.getFinalPrice();
    REQUIRE(finalPrice == Approx(40.0f)); // 80 - 50% = 40
}

TEST_CASE("Negative discount should increase price", "[Product]") {
    Product item;
    item.price = 100.0f;
    item.discount = -20.0f; // Negative discount

    float finalPrice = item.getFinalPrice();
    REQUIRE(finalPrice == Approx(120.0f)); // 100 - (-20%) = 120
}

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: Metodi della Classe

Implementazione dei metodi al di fuori della classe

Esempio

Soluzione