Summary  
This chapter explains how constructors are used to initialize class attributes—providing default values, accepting parameters, and supporting overloading for different argument sets.  

General domain of usage  
Object-oriented programming

L'une des principales utilisations des constructeurs **est d'initialiser les attributs** de la **classe**. Un **constructeur par défaut**, par exemple, peut être utilisé pour définir des valeurs initiales. Par exemple :








I2luY2x1ZGUgPGlvc3RyZWFtPgoKY2xhc3MgUGVyc29uIHsKcHVibGljOgogICAgUGVyc29uKCkgeyBuYW1lID0gInVuZGVmaW5lZCI7IH0KICAgIAogICAgc3RkOjpzdHJpbmcgbmFtZTsKfTsKCmludCBtYWluKCkKewogICAgUGVyc29uIHBlcnNvbjsKICAgIHN0ZDo6Y291dCA8PCBwZXJzb24ubmFtZTsKfQ==

Si vous ne spécifiez pas de valeur pour **l'attribut name** de l'**objet**, il sera défini sur <span style="color: gray; font-weight: bold;">underfined</span> **par défaut**. Vous pouvez essayer de supprimer ce constructeur pour observer les changements qui se produisent.

### Initialisation des attributs avec le constructeur

Comme les fonctions, les constructeurs peuvent prendre des paramètres, permettant ainsi différents arguments lors de la création d'un objet. Il est également possible de les surcharger pour gérer un nombre variable d'arguments.


Y2xhc3MgUGVyc29uIHsKcHVibGljOgogICAgUGVyc29uKHN0ZDo6c3RyaW5nIF9uYW1lLCBzdGQ6OnN0cmluZyBfc3VybmFtZSwgaW50IF9hZ2UpIAogICAgewogICAgICAgIG5hbWUgPSBfbmFtZTsKICAgICAgICBzdXJuYW1lID0gX3N1cm5hbWU7CiAgICAgICAgYWdlID0gX2FnZTsKICAgIH0KCiAgICBzdGQ6OnN0cmluZyBuYW1lOwogICAgc3RkOjpzdHJpbmcgc3VybmFtZTsKICAgIGludCBhZ2U7Cn07CgppbnQgbWFpbigpIAp7IAogICAgUGVyc29uIHBlcnNvbigiQm9iIiwgIlNvbmciLCAyMyk7IAp9

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

class Location {
public:
    std::string name;
    double x;
    double y;

    double distanceTo(const Location& other);
};

TEST_CASE("Distance between Home(1,2) and School(4,6) => 5", "[Location]") {
    Location home;
    home.name = "Home";
    home.x = 1.0;
    home.y = 2.0;

    Location school;
    school.name = "School";
    school.x = 4.0;
    school.y = 6.0;

    double dist = home.distanceTo(school);
    REQUIRE(dist == Approx(5.0)); // sqrt((4-1)^2 + (6-2)^2) = 5
}

TEST_CASE("Distance to self (Point(3,7) to Point(3,7)) => 0", "[Location]") {
    Location point;
    point.name = "Point";
    point.x = 3.0;
    point.y = 7.0;

    double dist = point.distanceTo(point);
    REQUIRE(dist == Approx(0.0));
}

TEST_CASE("Distance with negative coordinates (A(-2,-3) to B(1,1)) => 5", "[Location]") {
    Location a;
    a.name = "A";
    a.x = -2.0;
    a.y = -3.0;

    Location b;
    b.name = "B";
    b.x = 1.0;
    b.y = 1.0;

    double dist = a.distanceTo(b);
    REQUIRE(dist == Approx(5.0)); // sqrt((1+2)^2 + (1+3)^2) = 5
}

TEST_CASE("Distance along x-axis (A(0,0) to B(5,0)) => 5", "[Location]") {
    Location a;
    a.name = "A";
    a.x = 0.0;
    a.y = 0.0;

    Location b;
    b.name = "B";
    b.x = 5.0;
    b.y = 0.0;

    double dist = a.distanceTo(b);
    REQUIRE(dist == Approx(5.0));
}

TEST_CASE("Distance along y-axis (A(0,0) to B(0,7)) => 7", "[Location]") {
    Location a;
    a.name = "A";
    a.x = 0.0;
    a.y = 0.0;

    Location b;
    b.name = "B";
    b.x = 0.0;
    b.y = 7.0;

    double dist = a.distanceTo(b);
    REQUIRE(dist == Approx(7.0));
}

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: Constructeur et Attributs

Initialisation des attributs avec le constructeur

Exemple

Solution