Segmentation et Agrégation

Lorsque vous développez un logiciel maintenable et flexible, de nombreux aspects doivent être pris en compte, en particulier en programmation orientée objet. La composition et l’agrégation sont des concepts fondamentaux qui permettent la création de systèmes complexes à partir de composants plus simples et font partie du paradigme de l'encapsulation.

Composition

La composition est une technique de conception où une class contient des objects d'autres classes en tant que variables membres. Ces membres sont des composants essentiels de la class qui les contient et possèdent une relation de forte propriété. Lorsque l’object contenant est détruit, ses parties composées le sont également. Par exemple :

Car.h

Engine.h

#include "Engine.h"

class Car {

public:

void Start()

{

engine.Start(); // Start the engine

std::cout << "Car started" << std::endl;

}

private:

Engine engine; // Engine object composition

};


              123456789101112
            
#include "Engine.h"

class Car {
public:
    void Start() 
    {
        engine.Start(); // Start the engine
        std::cout << "Car started" << std::endl;
    }
private:
    Engine engine; // Engine object composition
};

La classe Car compose un objet Engine. Lorsqu'un objet Car est créé, il crée automatiquement une instance de Engine dans le cadre de sa composition.

Agrégation

L’agrégation est une autre forme de composition d’object où une class contient des object d’autres classes, mais les instances contenues ont une relation plus faible par rapport à la composition. Dans l’agrégation, les membres classes contenus peuvent exister indépendamment et peuvent être partagés entre plusieurs classes.

Car.h

Engine.h

#include "Engine.h"

class Car {

public:

Car(Engine* engine)

: engine(engine) {}

void Start()

{

engine->Start(); // Start the engine

std::cout << "Car started" << std::endl;

}

private:

Engine* engine; // Engine object aggregation

};


              123456789101112131415
            
#include "Engine.h"

class Car {
public:
    Car(Engine* engine) 
        : engine(engine) {}

    void Start() 
	{
        engine->Start(); // Start the engine
        std::cout << "Car started" << std::endl;
    }
private:
    Engine* engine; // Engine object aggregation
};

La classe Car agrège un objet Engine en utilisant un pointeur. La classe Car ne possède pas l'objet Engine ; elle se contente d'y faire référence. Cela permet à l'instance de Engine d'exister indépendamment de l'objet Car et d'être partagée entre plusieurs instances si nécessaire.

Choix entre composition et agrégation

Lors de la conception de systèmes logiciels, il est essentiel de bien réfléchir à l'utilisation de la composition ou de l'agrégation en fonction des relations entre les classes et les objets.

Dans le contexte des classes Car et Engine, l'utilisation de la composition serait plus appropriée. Chaque voiture possède généralement son propre moteur, et le moteur fait partie intégrante de la voiture elle-même. De plus, cela empêche le partage ou la réutilisation du Engine entre plusieurs objets objects, ce qui est également cohérent.

Tout était clair ?

Merci pour vos commentaires !

Section 3. Chapitre 5

Demandez à l'IA

Posez n'importe quelle question ou essayez l'une des questions suggérées pour commencer notre discussion