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)

Les méthodes dans une **classe** sont essentiellement **des fonctions qui sont définies à l'intérieur de la classe**. Elles servent à définir les comportements ou actions que les **objets** de la **classe** peuvent effectuer.




Les méthodes manipulent souvent les attributs de la **classe** ou effectuent des opérations pertinentes pour les **objets**.

### Implémentation des méthodes en dehors de la classe

Les méthodes peuvent être définies en dehors de la déclaration de la `class` en utilisant l'**opérateur de résolution de portée** (`::`). Cela est souvent fait pour séparer la déclaration dans le fichier d'en-tête de son implémentation dans le fichier source. Voici comment procéder :

Y2xhc3MgRXhhbXBsZSB7CnB1YmxpYzoKICAgIHZvaWQgTWV0aG9kKCk7Cn07

I2luY2x1ZGUgIkV4YW1wbGUuaCIKCnZvaWQgRXhhbXBsZTo6TWV0aG9kKCkKewogICAgc3RkOjpjb3V0IDw8ICJNZXRob2Qgd2FzIGNhbGxlZCIgPDwgc3RkOjplbmRsOwp9

Il **n'est pas obligatoire de créer deux fichiers distincts** pour cet objectif ; cela peut être réalisé dans un seul fichier, et dans certaines situations, cela s'avère avantageux.

I2luY2x1ZGUgPGlvc3RyZWFtPgoKY2xhc3MgRXhhbXBsZSB7CnB1YmxpYzoKICAgIHZvaWQgTWV0aG9kKCk7Cn07Cgp2b2lkIEV4YW1wbGU6Ok1ldGhvZCgpIHsgc3RkOjpjb3V0IDw8ICJNZXRob2Qgd2FzIGNhbGxlZCIgPDwgc3RkOjplbmRsOyB9

La bonne pratique courante consiste à **séparer la déclaration et l’implémentation**.

#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 programmation orientée objet (POO) en C++ vous aide à créer un code propre, réutilisable et évolutif en organisant les programmes autour des objets et des classes. Vous apprendrez à définir et utiliser des classes, à créer des constructeurs et des destructeurs, et à appliquer l'encapsulation pour protéger les données. Des sujets tels que l'héritage, le polymorphisme, les membres statiques, le contrôle d'accès et la surcharge des opérateurs vous aideront à concevoir des structures de code flexibles et efficaces.

Apprenez à créer des classes et des objets, à définir des attributs et des méthodes, à travailler avec des membres statiques et le mot-clé this. Acquérez une base solide sur la manière dont les objets interagissent et sur la façon d'écrire un code propre et modulaire en utilisant les principes de la POO.

Apprenez comment les constructeurs et les destructeurs gèrent la création et la destruction des objets. Exercez-vous à utiliser les listes d'initialisation, la délégation de constructeur et à écrire un code propre et efficace avec une gestion appropriée du cycle de vie des objets.

Découvrez comment l'encapsulation, l'un des principes fondamentaux de la POO, améliore la modularité et la maintenabilité du code grâce à la dissimulation des données, au contrôle d'accès et à l'utilisation de méthodes d'accès et de modification.

Découvrez le mécanisme fondamental de la programmation orientée objet qui permet la réutilisation du code et favorise la création de relations hiérarchiques entre les classes.

Le polymorphisme est un concept fondamental en POO qui permet la création de structures de code flexibles et extensibles. Vous apprendrez les fonctions virtuelles, les classes abstraites et la surcharge des opérateurs ainsi que leurs rôles essentiels dans la promotion de la flexibilité et de l'évolutivité du code.

Challenge : Méthodes de la Classe

Implémentation des méthodes en dehors de la classe

Solution