Quelle est la différence entre l'association, l'agrégation et la composition?

• L'Association est une relation où tous les objets ont leur propre cycle de vie et il n'y a pas de propriétaire.

  prenons un exemple D'enseignant et D'élève. Plusieurs élèves peuvent s'associer avec un seul enseignant et un élève peut s'associer avec plusieurs enseignants, mais il n'y a pas de propriété entre les objets et les deux ont leur propre cycle de vie. Les deux peuvent être créés et supprimés indépendamment.

• "Aggregation est une forme spécialisée d'Association où tous les objets ont leur propre cycle de vie, mais il y a Propriété et les objets enfants ne peuvent pas appartenir à un autre objet parent.

  prenons un exemple de département et d'enseignant. Un seul enseignant ne peut pas appartenir à plusieurs départements, mais si nous supprimons le département, l'objet enseignant sera et non détruit. On peut y voir un "has-a"" relation.

• Composition est à nouveau une forme spécialisée d'agrégation et nous pouvons l'appeler comme une relation de "mort". C'est un type d'Agrégation. L'objet enfant n'a pas son cycle de vie et si l'objet parent est supprimé, tous les objets enfant seront également supprimés.

  reprenons un exemple de relation entre la maison et les pièces. La maison peut contenir plusieurs chambres - il n'est pas indépendant vie de la chambre et de n'importe quelle pièce ne peut pas appartenir à deux maisons différentes. Si nous supprimons la maison - chambre sera automatiquement supprimé.

  prenons un autre exemple de relation entre les questions et les Options. Les questions simples peuvent avoir plusieurs options et option ne peut pas appartenir à des questions multiples. Si nous supprimons les questions, les options seront automatiquement supprimés.

pour deux objets, Foo et Bar les relations peuvent être définies

Association - j'ai une relation avec un objet. Foo utilise Bar

public class Foo { 
    void Baz(Bar bar) {
    } 
};

Composition-Je possède un objet et je suis responsable de sa vie, lorsque Foo meurt, ainsi que Bar

public class Foo {
    private Bar bar = new Bar(); 
}

Agrégation j'ai un objet qui j'ai emprunté à quelqu'un d'autre. Lorsque Foo meurt", 151940920" est susceptible de vivre.

public class Foo { 
    private Bar bar; 
    Foo(Bar bar) { 
       this.bar = bar; 
    }
}

je sais que cette question est marquée comme C# mais les concepts sont assez génériques questions comme ceci rediriger ici. Je vais donc donner mon point de vue ici (un peu biaisé du point de vue de java où je suis plus à l'aise).

quand nous pensons à la nature orientée objet, nous pensons toujours aux objets, à la classe (aux plans d'objets) et à la relation entre eux. Les objets sont reliés et interagissent les uns avec les autres par des méthodes. En d'autres termes objet d'une classe peut utiliser des services/Méthodes fournis par objet d'une autre classe. Ce type de relation est appelé association . .

L'agrégation et la Composition sont des sous-ensembles de l'association ce qui signifie qu'il s'agit de cas spécifiques d'association.

• à la fois dans l'agrégation et la composition objet d'une classe "possède" objet d'une autre classe .
• mais il y a une différence subtile. Dans Composition l'objet de classe qui est possédé par l'objet de sa classe propriétaire ne peut pas vivre sur lui-même (également appelé"relation de mort"). Il vivra toujours comme une partie de son objet de propriété où comme dans agrégation l'objet dépendant est autonome et peut exister même si l'objet de propriété la classe est morte.
• ainsi dans la composition si posséder objet est ordures collectées l'objet possédé sera aussi ce qui n'est pas le cas dans l'agrégation.

confus?

exemple de Composition : prenons l'exemple d'une voiture et d'un moteur qui est très spécifique à cette voiture (ce qui signifie qu'il ne peut pas être utilisé dans une autre voiture). Ce type de relation bateau entre voiture et La classe de moteur spécifique est appelée Composition. Objet de la classe de voiture ne peut pas exister sans objet de la classe de moteur spécifique et objet de la classe de moteur spécifique n'a pas de signification sans classe de voiture. Pour mettre en mots simples Classe De Voiture uniquement "possède" la classe de moteur spécifique.

exemple D'agrégation : considérons maintenant la classe Wagon et la classe roue . La voiture a besoin d'un objet de roue pour fonctionner. Signification voiture objet propre Objet de roue mais nous ne pouvons pas dire que L'objet de roue n'a pas de signification Sans objet de voiture. Il peut très bien être utilisé dans un vélo, camion ou différentes voitures objet.

en résumé -

pour résumer l'association est un terme très générique utilisé pour représenter lorsqu'on utilise les fonctionnalités fournies par une autre classe. Nous disons que c'est la composition si un objet de classe parent possède un autre objet de classe enfant et que cet objet de classe enfant ne peut pas exister de manière significative sans l'objet de classe parent. Si elle le peut, elle est appelée agrégation.

plus de détails ici.

Association est un concept généralisé de relations. Elle comprend à la fois la Composition et l'agrégation.

Composition ( mélange ) est un moyen d'envelopper des objets simples ou des types de données dans une unité unique . Les Compositions sont une composante essentielle de nombreuses structures de données de base

agrégation ( collecte ) diffère de la composition ordinaire en ce qu'elle n'implique pas la propriété. Dans la composition, lorsque l'objet propriétaire est détruit, les objets contenus le sont aussi. Dans l'agrégation, ce n'est pas nécessairement vrai.

les deux indiquent une relation entre l'objet et ne diffèrent que par leur force.

Astuce pour se souvenir de la différence : a Un - Un ggregation et O wn-c O mpositoin

voyons maintenant l'image suivante

analogie:

Composition : l'image suivante est la composition de l'image, c'est-à-dire l'utilisation d'images individuelles pour faire une image.

agrégation : collection d'images en un seul lieu

par exemple, une université possède divers départements, et chaque département compte un certain nombre de professeurs. Si l'Université ferme, les départements n'existeront plus, mais les professeurs de ces départements continueront d'exister. Par conséquent, une université peut être considérée comme une composition de départements, alors que les départements ont un regroupement de professeurs. En outre, un Professeur peut travailler dans plus d'un département, mais un ministère ne peut pas faire partie de plus d'une université.

à Partir d'un post par Robert Martin dans comp.objet :

représente la capacité d'une instance à envoyer un message à une autre instance. Ceci est typiquement implémenté avec un indicateur ou une variable d'instance de référence, bien qu'il puisse aussi être implémenté comme un argument de méthode, ou la création d'une variable locale.

//[Example:]

//|A|----------->|B|

class A
{
  private:
    B* itsB;
};

agrégation [...] est la relation typique entre l'ensemble et la partie. C'est exactement le même chose qu'une association à l'exception que les instances ne peuvent pas avoir des relations d'agrégation cycliques (c'est-à-dire qu'une partie ne peut pas contenir son entier).

//[Example:]

//|Node|<>-------->|Node|

class Node
{
  private:
    vector<Node*> itsNodes;
};

le fait qu'il s'agisse d'une agrégation signifie que les instances de noeud ne peuvent pas former un cycle. Ainsi, C'est un arbre de noeuds pas un graphe de noeuds.

Composition [...] est exactement comme l'Agrégation, sauf que la durée de vie de la partie est contrôlée par la "totalité". Ce contrôle peut être direct ou transitive. C'est-à-dire que le "tout" peut assumer la responsabilité directe de la création ou de la destruction de la "partie", ou il peut accepter une partie déjà créée, et ensuite la transmettre à un autre tout qui en assume la responsabilité.

//[Example:]

//|Car|<#>-------->|Carburetor|

class Car
{
  public:
    virtual ~Car() {delete itsCarb;}
  private:
    Carburetor* itsCarb
};

dépendance (références)

Il n'y a pas de lien conceptuel entre deux objets. e.g. Enrolmentservice object references Student & Course objects (as method parameters or return types)

public class EnrollmentService {
    public void enroll(Student s, Course c){}
}

Association (has-a)

Il n'y a presque toujours un lien entre les objets (ils sont liés). Article d'ordre a un objet client

public class Order {
    private Customer customer
}

Agrégation (a-a + tout-partie)

Type spécial d'association où il y a une relation entière-partie entre deux objets. ils pourraient vivre l'un sans l'autre.

public class PlayList{
    private List<Song> songs;
}

Note: la partie la plus délicate est de distinguer l'agrégation de l'association normale. Honnêtement, je pense que c'est ouvert à différentes interprétation.

Composition (a-a + pour la pièce entière + de propriété)

Genre spécial de l'agrégation. Un Apartment est composé de Room . Un Room ne peut exister sans un Apartment . lorsqu'un appartement est supprimé, tous les associés les chambres sont supprimés.

public class Apartment{
    private Room bedroom;
    public Apartment() {
       bedroom = new Room();
    }
}

comme d'autres l'ont dit, une association est une relation entre des objets, l'agrégation et la composition sont des types d'association.

du point de vue de la mise en œuvre, une agrégation est obtenue en ayant un membre de classe par référence . Par exemple, si la classe A regroupe un objet de la Classe B, vous aurez quelque chose comme ceci (en C++):

class A {
    B & element;
  // or B * element;
};

La sémantique de l'agrégation, c'est que lorsqu'Un objet est détruit, l'objet B qu'il stocke existera toujours. Lorsque vous utilisez la composition, vous avez une relation plus forte, généralement en stockant le membre en valeur :

class A {
    B element;
};

Ici, quand Un objet est détruit, l'objet B, il contient sera détruit. La manière la plus simple d'y parvenir est de stocker le membre par valeur, mais vous pouvez également utiliser un pointeur intelligent, ou supprimer le membre dans le destructeur:

class A {
    std::auto_ptr<B> element;
};

class A {
    B * element;

    ~A() {
        delete B;
    }
};

le point important est que dans une composition, le conteneur objet possède le contenu, tandis que dans l'agrégation, il se réfère il.

c'est étonnant combien de confusion existe sur la distinction entre les trois concepts de relation association , agrégation et composition .

notez que les Termes agrégation et composition ont été utilisés dans la communauté C++, probablement depuis un certain temps avant qu'ils aient été définis comme des cas spéciaux de association dans les diagrammes de classe UML.

le problème principal est l'incompréhension généralisée et continue (même parmi les développeurs de logiciels experts) que le concept de composition implique une dépendance du cycle de vie entre le tout et ses parties de sorte que les parties ne peuvent pas exister sans le tout, ignorant le fait qu'Il ya aussi des cas d'associations de la partie-tout avec les parties non partageables où les parties peuvent être détachées de, et survivre à la destruction de, ensemble.

pour autant que je puisse voir, cette confusion a deux racines:

1. dans la communauté C++, le terme "agrégation" a été utilisé dans le sens d'une classe définissant un attribut pour référencer des objets d'une autre classe indépendante (voir, par exemple, [1]), qui est le sens de association dans les diagrammes de classe UML. Le terme "composition" a été utilisé pour les classes qui définissent les objets composants pour leurs objets, de sorte que: sur la destruction de l'objet composite, ces objets sont détruits.

2. dans les diagrammes de classe UML, les Termes "agrégation" et "composition" ont été définis comme des cas particuliers d'associations représentant des relations en partie-entières (qui ont été discutées dans la philosophie depuis longtemps). Dans leurs définitions, la distinction entre une "agrégation" et une "composition" est basé sur le fait si cela permet de partager une partie entre deux ou plusieurs ensembles. Ils définissent les " compositions "comme ayant des parties non partageables (exclusives), tandis que les" agrégations " peuvent partager leurs parties. En outre, ils disent quelque chose comme ceci: très souvent, mais pas dans tous les cas, les compositions viennent avec une dépendance du cycle de vie entre le tout et ses parties de sorte que les parties ne peuvent pas exister sans le tout.

ainsi, alors que UML a mis les Termes "agrégation" et "composition" dans le bon contexte (de relations partielles-entières), ils n'ont pas réussi à les définir d'une manière claire et sans ambiguïté, capturant les intuitions des développeurs. Cependant, ce n'est pas surprenant car il y a tellement de propriétés différentes (et de nuances d'implémentation) que ces relations peuvent avoir, et les développeurs ne s'entendent pas sur la façon de les mettre en œuvre.

Voir aussi mon extension de réponse à la question de l'Apr 2009 énumérés ci-dessous.

et la propriété qui a été supposée définir la" composition "entre les objets OOP dans la communauté C++ (et cette croyance est encore largement répandue): la dépendance du cycle de vie entre les deux objets liés (le composite et sa composante), n'est pas vraiment caractéristique pour la" composition " parce que nous pouvons avoir de telles dépendances en raison de l'intégrité référentielle aussi dans d'autres types d'associations.

par exemple, le code suivant le modèle de "composition" a été proposé dans an SO an an an an answer :

final class Car {    
  private final Engine engine;

  Car(EngineSpecs specs) {
    engine = new Engine(specs);
  }

  void move() {
    engine.work();
  }
}

l'intimé a fait valoir qu'il serait caractéristique pour la" composition " qu'aucune autre classe ne puisse faire référence à l'élément ou le connaître. Cependant, ce n'est certainement pas vrai pour tous les cas possibles de "composition". En particulier, dans le cas d'un moteur de voiture, le fabricant de la voiture, éventuellement mis en œuvre avec l'aide d'une autre classe, peut avoir pour référence le moteur pour être possibilité de contacter le propriétaire de la voiture en cas de problème.

[1] http://www.learncpp.com/cpp-tutorial/103-aggregation /

Annexe - liste Incomplète, à plusieurs reprises, posé des questions à propos de la composition rapport à l'agrégation sur StackOverflow

[ Apr 2009 ]

l'Agrégation rapport à la Composition [fermé comme principalement opinion par]

[ Apr 2009 ]

Quelle est la différence entre la Composition et la relation D'Association? [ May 2009 ]

différence entre association, agrégation et composition

[ Peut 2009 ]

Quelle est la différence entre composition et agrégation? [dupliquer]

[ Oct 2009 ]

Quelle est la différence entre agrégation, composition et dépendance? [duplicata]

[ Nov 2010 ]

Association vs. agrégation [indiqué en double]

[ Aug 2012 ]

implémentation différence entre agrégation et Composition en Java

[ Fév 2015 ]

le langage de modélisation UML de l'association ou de l'agrégation (de simples fragments de code)

Association

L'Association représente la relation entre deux classes.Elle peut être unidirectionnelle(unidirectionnelle) ou bidirectionnelle (bidirectionnelle)

par exemple:

1. unidirectionnel

le client passe une commande

2. bidirectionnel

A est marié à B

B est marié à a

agrégation

L'agrégation est une sorte d'association.Mais avec des caractéristiques spécifiques.L'agrégation est la relation dans une classe "entière" plus grande contenant une ou plusieurs classes "de parties" plus petites.À l'inverse, une classe plus petite de "pièces" est une pièce de "tout" le plus grand de la classe.

par exemple:

club a des membres

Un club " ("ensemble") est composé de plusieurs membres du club("parties").Les membres ont la vie à l'extérieur du club. Si le club ("tout") devait mourir, les membres ("Parties") ne mourraient pas avec. Parce que le membre peut appartenir à plusieurs clubs ("entier").

Composition

il s'agit d'une forme d'agrégation plus forte."Ensemble" est responsable pour la création ou la destruction de ses "parties"

par exemple:

une école a des départements

Dans ce cas, l'école("ensemble") étaient à mourir, département("parties") mourrait avec elle. Car chaque partie peut appartenir qu'à un seul "ensemble".

il est important de comprendre pourquoi nous devrions même prendre la peine d'utiliser plus d'une ligne relationnelle. La raison la plus évidente est de décrire la relation parent-enfant entre les classes (lorsque le parent a supprimé tous ses enfants sont supprimés en conséquence), mais plus impuissants, nous voulons distinguer entre simple association et la composition afin de placer des restrictions implicites sur la visibilité et la propagation des changements aux classes liées, une question qui joue un rôle important dans comprendre et réduire la complexité du système .

Association

la façon la plus abstraite de décrire la relation statique entre classes est d'utiliser le lien D'Association, qui indique simplement qu'il existe une sorte de lien ou de dépendance entre deux classes ou plus.

Faible Association

Classe A peut être liée à la Classe B afin de montrer que l'une de ses méthodes inclut le paramètre D'instance ClassB, ou l'instance returns de ClassB.

Forte Association

ClassA peut également être lié à ClassB afin de démontrer qu'il contient une référence à une instance de ClassB.

Agrégation (Association Partagée)

dans les cas où il y a une partie de relation entre la Classe A (entier) et ClassB (part), nous pouvons être plus précis et utiliser le lien d'agrégation au lieu du lien d'association, en soulignant que ClassB peut également être agrégé par d'autres classes dans l'application (donc l'agrégation est également connu sous le nom d'association partagée).

il est important de noter que le lien d'agrégation n'indique en aucune façon que Classea possède Classeb ni qu'il y a un parent-enfant relation (lorsque le parent a supprimé tous ses enfants sont supprimés en conséquence) entre les deux. En fait, bien au contraire! Le lien d'agrégation habituellement utilisé pour souligner le point que ClassA n'est pas le conteneur exclusif de Classeb, comme en fait Classeb a un autre conteneur.

Aggregation v. S. Association Le lien d'association peut remplacer le lien d'agrégation dans chaque situation, tandis que l'agrégation ne peut pas remplacer l'association dans les situations où il n'y a qu'un "lien faible" entre les classes, C'est-à-dire que ClassA a une/des Méthode (s) qui contiennent le paramètre ClassB mais ClassA ne contient pas de référence à L'instance ClassB.

Martin Fowler suggère que le lien d'agrégation ne devrait pas être utilisé du tout parce qu'il n'a aucune valeur ajoutée et qu'il perturbe la cohérence, citant Jim Rumbaugh "pensez-y comme un placebo de modélisation".

Composition (Association Non Partagée)

nous devrions être plus précis et utiliser le lien de composition dans les cas où, en plus de la partie de la relation entre ClassA et ClassB - Il ya une forte dépendance du cycle de vie entre les deux, ce qui signifie que lorsque ClassA est supprimé alors ClassB est également supprimé en conséquence

le lien de composition montre qu'une classe (conteneur, entier) a la propriété exclusive sur d'autres Classe / s (parties), ce qui signifie que l'objet contenant et ses parties constituent une relation parent-enfant.

contrairement à l'association et à l'agrégation, lorsqu'on utilise la relation de composition, la classe composée ne peut pas apparaître comme un type de retour ou un type de paramètre de la classe composite. Ainsi, les modifications de la classe composée ne peuvent pas se propager au reste du système. Par conséquent, l'utilisation de la composition limite la croissance de la complexité au fur et à mesure que le système se développe.

complexité des systèmes de mesure

la complexité du système peut être mesurée simplement en regardant un diagramme de classe UML et en évaluant les lignes de relation d'association, d'agrégation et de composition. La façon de mesurer la complexité consiste à déterminer combien de classes peuvent être affectées par le changement d'une classe particulière. Si la classe A expose la Classe B, alors toute classe donnée qui utilise la classe A peut théoriquement être affectée par des changements à la classe B. La somme du nombre de les classes potentiellement affectées pour chaque classe du système sont la complexité totale du système.

vous pouvez lire plus ici: http://aviadezra.blogspot.com/2009/05/uml-association-aggregation-composition.html

une relation entre deux objets est appelée association .

une association est appelée composition lorsqu'un objet en possède un autre.

alors qu'une association est appelée agrégation lorsqu'un objet utilise un autre objet.

le problème avec ces réponses est qu'elles sont la moitié de l'histoire: elles expliquent que l'agrégation et la composition sont des formes d'association, mais elles ne disent pas s'il est possible qu'une association ne soit ni l'une ni l'autre.

j'ai compris sur la base de quelques brèves lectures de nombreux billets sur SO et certains UML docs qu'il y a 4 formes concrètes principales d'association de classe:

1. composition: A est-composé - D'A B; B n'existe pas sans a, comme une salle dans une maison
2. agrégation: a-B; B peut exister sans Un, comme un étudiant en classe
Dépendance
3. : a utilise-a B; Pas de dépendance du cycle de vie entre A et B, comme un paramètre d'appel de méthode, une valeur de retour, ou un temporaire créé pendant un appel de méthode
4. généralisation: A est un B

Lorsqu'une relation entre deux entités n'est pas l'une d'elles, elle peut simplement être appelée "une association" dans le générique les sens du terme, et décrit d'autres méthodes (remarque, stéréotype, etc).

à mon avis, l '"association générique" est destinée à être utilisée principalement dans deux circonstances:

• lorsque les détails d'une relation sont encore en cours d'élaboration; une telle relation dans un diagramme doit être convertie dès que possible à ce qu'elle est/sera effectivement (l'un des 4 autres).
• quand une relation ne correspond à aucune parmi ces 4 préétablis par UML, l'association "generic" vous donne encore une façon de représenter une relation qui n'est "pas l'un des autres", de sorte que vous n'êtes pas coincé en utilisant une relation incorrecte avec une note "ce n'est pas réellement l'agrégation, C'est juste que UML n'a pas d'autre symbole que nous pourrions utiliser"

je pense que ce lien fera vos devoirs: http://ootips.org/uml-hasa.html

pour comprendre les Termes, je me souviens d'un exemple dans Mes premiers jours de programmation:

si vous avez un objet' échiquier 'qui contient des objets' boîte 'qui est composition parce que si le' échiquier ' est supprimé il n'y a aucune raison pour que les boîtes existent plus.

Si vous avez un 'carré' objet qui ont un objet 'color' et le carré est supprimé l'objet 'color' peut encore exister, c'est-à-dire agrégation

les deux sont associations , la principale différence est conceptuelle

Composition : C'est là qu'une fois qu'on détruit un objet (L'école), un autre objet (les salles de classe) qui s'y rattache serait également détruit. Les deux ne peuvent pas exister indépendamment.

agrégation : C'est l'exact opposé de l'association ci-dessus ( Composition ) où une fois que vous tuez un objet ( Company ), l'autre objet ( Employees ) qui est lié à lui peut exister sur son propre.

Association .

La Composition et l'Agrégation sont les deux formes d'association.

Composition (si vous supprimez "entier", " partie "est également supprimé automatiquement–" propriété")

• créez des objets de votre classe existante dans la nouvelle classe. Cela s'appelle composition parce que la nouvelle classe est composée d'objets des classes existantes.

• utilise généralement des variables de membre normales.

• peut utiliser pointeur valeurs si la classe de composition gère automatiquement l'attribution/désallocation responsable de la création/destruction des sous-classes.

Composition en C++

#include <iostream>
using namespace std;
/********************** Engine Class ******************/
class Engine
{
    int nEngineNumber;
    public:
    Engine(int nEngineNo);
    ~Engine(void);
};
Engine::Engine(int nEngineNo)
{
    cout<<" Engine :: Constructor " <<endl;
}
Engine::~Engine(void)
{
    cout<<" Engine :: Destructor " <<endl;
}
/********************** Car Class ******************/
class Car
{
    int nCarColorNumber;
    int nCarModelNumber;
    Engine objEngine;
    public:
    Car (int, int,int);
    ~Car(void);
};
Car::Car(int nModelNo,int nColorNo, int nEngineNo):
nCarModelNumber(nModelNo),nCarColorNumber(nColorNo),objEngine(nEngineNo)
{
    cout<<" Car :: Constructor " <<endl;
}
Car::~Car(void)
{
    cout<<" Car :: Destructor " <<endl;
    Car
    Engine
    Figure 1 : Composition
}
/********************** Bus Class ******************/
class Bus
{
    int nBusColorNumber;
    int nBusModelNumber;
    Engine* ptrEngine;
    public:
    Bus(int,int,int);
    ~Bus(void);
};
Bus::Bus(int nModelNo,int nColorNo, int nEngineNo):
nBusModelNumber(nModelNo),nBusColorNumber(nColorNo)
{
    ptrEngine = new Engine(nEngineNo);
    cout<<" Bus :: Constructor " <<endl;
}
Bus::~Bus(void)
{
    cout<<" Bus :: Destructor " <<endl;
    delete ptrEngine;
}
/********************** Main Function ******************/
int main()
{
    freopen ("InstallationDump.Log", "w", stdout);
    cout<<"--------------- Start Of Program --------------------"<<endl;
    // Composition using simple Engine in a car object
    {
        cout<<"------------- Inside Car Block ------------------"<<endl;
        Car objCar (1, 2,3);
    }
    cout<<"------------- Out of Car Block ------------------"<<endl;
    // Composition using pointer of Engine in a Bus object
    {
        cout<<"------------- Inside Bus Block ------------------"<<endl;
        Bus objBus(11, 22,33);
    }
    cout<<"------------- Out of Bus Block ------------------"<<endl;
    cout<<"--------------- End Of Program --------------------"<<endl;
    fclose (stdout);
}

Sortie

--------------- Start Of Program --------------------
------------- Inside Car Block ------------------
Engine :: Constructor
Car :: Constructor
Car :: Destructor
Engine :: Destructor
------------- Out of Car Block ------------------
------------- Inside Bus Block ------------------
Engine :: Constructor
Bus :: Constructor
Bus :: Destructor
Engine :: Destructor
------------- Out of Bus Block ------------------
--------------- End Of Program --------------------

Agrégation (Si vous supprimez "ensemble", "Partie" peut exister, " Pas de Propriété")

• une agrégation est un type spécifique de composition où aucune propriété entre l'objet complexe et les sous-objets n'est implicite. Lorsqu'un agrégat est détruit, les sous-projets ne sont pas détruits.

• typiquement utiliser des variables indicatrices / variable de référence qui pointent vers un objet qui vit en dehors de la portée de la classe agrégée

• peut utiliser valeurs de référence indiquant un objet qui ne relève pas de la classe agrégée

• Non responsable de la création/destruction des sous-classes

code D'agrégation en C++

#include <iostream>
#include <string>
using namespace std;
/********************** Teacher Class ******************/
class Teacher
{
    private:
    string m_strName;
    public:
    Teacher(string strName);
    ~Teacher(void);
    string GetName();
};
Teacher::Teacher(string strName) : m_strName(strName)
{
    cout<<" Teacher :: Constructor --- Teacher Name :: "<<m_strName<<endl;
}
Teacher::~Teacher(void)
{
    cout<<" Teacher :: Destructor --- Teacher Name :: "<<m_strName<<endl;
}
string Teacher::GetName()
{
    return m_strName;
}
/********************** Department Class ******************/
class Department
{
    private:
    Teacher *m_pcTeacher;
    Teacher& m_refTeacher;
    public:
    Department(Teacher *pcTeacher, Teacher& objTeacher);
    ~Department(void);
};
Department::Department(Teacher *pcTeacher, Teacher& objTeacher)
: m_pcTeacher(pcTeacher), m_refTeacher(objTeacher)
{
    cout<<" Department :: Constructor " <<endl;
}
Department::~Department(void)
{
    cout<<" Department :: Destructor " <<endl;
}
/********************** Main Function ******************/
int main()
{
    freopen ("InstallationDump.Log", "w", stdout);
    cout<<"--------------- Start Of Program --------------------"<<endl;
    {
        // Create a teacher outside the scope of the Department
        Teacher objTeacher("Reference Teacher");
        Teacher *pTeacher = new Teacher("Pointer Teacher"); // create a teacher
        {
            cout<<"------------- Inside Block ------------------"<<endl;
            // Create a department and use the constructor parameter to pass the teacher to it.
            Department cDept(pTeacher,objTeacher);
            Department
            Teacher
            Figure 2: Aggregation
        } // cDept goes out of scope here and is destroyed
        cout<<"------------- Out of Block ------------------"<<endl;
        // pTeacher still exists here because cDept did not destroy it
        delete pTeacher;
    }
    cout<<"--------------- End Of Program --------------------"<<endl;
    fclose (stdout);
}

Sortie

--------------- Start Of Program --------------------
Teacher :: Constructor --- Teacher Name :: Reference Teacher
Teacher :: Constructor --- Teacher Name :: Pointer Teacher
------------- Inside Block ------------------
Department :: Constructor
Department :: Destructor
------------- Out of Block ------------------
Teacher :: Destructor --- Teacher Name :: Pointer Teacher
Teacher :: Destructor --- Teacher Name :: Reference Teacher
--------------- End Of Program --------------------

je voudrais illustrer comment les trois termes sont mis en œuvre dans les Rails. ActiveRecord appelle association tout type de relation entre deux modèles . On ne trouve pas très souvent les Termes composition et aggregation , lors de la lecture de documents ou d'articles, liés à ActiveRecord. Une association est créée en ajoutant une des macros de la classe association au corps de la classe. Certains de ces macros sont belongs_to , has_one , has_many etc..

si nous voulons mettre en place un composition ou aggregation , nous devons ajouter belongs_to au modèle propriétaire (également appelé enfant) et has_one ou has_many au modèle propriétaire (également appelé parent). Que nous configurions composition ou aggregation dépend des options que nous passerons à l'appel belongs_to dans le modèle enfant. Avant Rails5, la configuration belongs_to sans aucune option créait un aggregation , l'enfant pouvait exister sans un parent. Si nous voulions un composition , il fallait le déclarer explicitement en ajoutant l'option required: true :

class Room < ActiveRecord::Base
  belongs_to :house, required: true
end

dans les Rails 5, ceci a été changé. Maintenant, déclarer une association belongs_to crée une association composition par défaut, l'enfant ne peut pas exister sans un parent. Ainsi, l'exemple ci-dessus peut être réécrit comme suit:

class Room < ApplicationRecord
  belongs_to :house
end

si nous voulons permettre à l'objet enfant d'exister sans parent, nous devons le déclarer explicitement via l'option optional

class Product < ApplicationRecord
  belongs_to :category, optional: true
end

dans une phrase très simple: L'agrégation et la Composition sont des sous-ensembles d'association. Une utilisation B -> c'est une agrégation, Un besoin B> est composition. lire la suite ici .