Comment afficher l'agrégation en termes de code de programmation?

Question

Je connais l'Association et l'Agrégation et la Composition et la Généralisation ce qu'ils sont par définition. l'héritage est "une relation" et la composition est "a une" relation.

Class A { 
} 

Class B extends A { // this is Generalization 
} 

Class C { 
A ob; // this is composition 
} 

maintenant ma question est de savoir comment l'agrégation et l'association simple est représentée en termes de code de programmation. ?

Answer 1

I soupçonne que votre vraie question a à voir avec la composition par rapport à l'agrégation. Vous pouvez penser à la différence en termes de propriété, mais la vraie distinction (pour mon argent) est ce qui contrôle le cycle de vie de l'objet agrégé.

En composition. quand l'objet composé est détruit, ses parties ou classes contenues sont détruites avec lui. Avec l'agrégation, la durée de vie de l'objet contenu peut être indépendante de l'objet conteneur. Dans du code. cela revient à savoir si l'objet composant est spécifié par valeur ou référence. L'agrégation a à faire par référence (ou pointeur comme dans l'exemple). Si c'est fait par valeur, la partie composant sera hors de portée et sera détruite avec l'objet contenant et est donc la composition. Donc, dans ce cas, le moteur est un exemple de composition et la batterie un exemple d'agrégation.

#include <iostream> 

using namespace std; 

class Engine 
{ 
    public: 

     Engine() {cout << "Engine created\n";}; 
    ~Engine() {cout << "Engine destroyed\n";}; 
}; 


class Battery 
{ 
    public: 

     Battery() {cout << "Battery created\n\n";}; 
    ~Battery() {cout << "\nBattery destroyed\n";}; 
}; 

class Car 
{ 
    private: 

     Battery *bat; 
     Engine eng; //Engine will go out of scope with Car 

    public: 

     Car(Battery* b) : bat(b) {cout << "Car created\n";}; 
    ~Car() {cout << "Car destroyed\n";}; 

     void drive(int miles) {/*...*/}; 
}; 



int main(int argc, char *argv[]) 
{ 
    //a Battery lifecycle exists independently of a car 
    Battery* battery = new Battery(); 

    //but a car needs to aggregate a Battery to run 
    Car* car1 = new Car(battery); 

    car1->drive(5); 

    //car1 and its Engine destroyed but not the Battery 
    delete car1; 

    cout << "---------------\n"; 

    //new car, new composed Engine, same old Battery 
    Car* car2 = new Car(battery); 

    car2->drive(5); 
    delete car2; 

    //destroy battery independently of the cars 
    delete battery; 

} 

Excuses si ce n'est pas le meilleur exemple mais j'espère que cela illustre le point principal.

Answer 2

Je ne sais pas exactement ce que vous allez pour, mais je suggère les exemples suivants:

agrégation

public class A { } 
public class List<A> { } // aggregation of A 

Association (utilisations)

public class A 
{ 
    public void AMethod() { ... } 

public class B 
{ 
    public void BMethod(A a) 
    { 
     a.AMethod(); // B uses A 
    } 
}