Come mostrare Aggregazione in termini di un codice di programmazione?

Question

So di associazione e aggregazione e composizione e la generalizzazione quello che sono per definizione. ereditarietà è "è una" relazione e la composizione è "ha un" rapporto.

Class A {
}

Class B extends A { // this is Generalization
}

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

Ora la mia domanda è come l'aggregazione e associazione semplice è mostrato in termini di codice di programmazione. ?

Answer 1

Ho il sospetto che la tua vera domanda ha a che fare con la composizione contro l'aggregazione. Si può pensare alla differenza in termini di proprietà, ma la vera distinzione (per i miei soldi) è ciò che controlla il ciclo di vita dell'oggetto aggregato.

In composizione. quando l'oggetto composto viene distrutto suoi componenti o classi contenute sono distrutte con esso. Con l'aggregazione, la vita del oggetto contenuto può essere indipendente dell'oggetto che contiene. Nel codice. questo si riduce a se l'oggetto componente è specificato dal valore o di riferimento. Aggregazione ha per essere fatto da riferimento (o puntatore come nell'esempio). Se è fatto in base al valore della componente andrà fuori portata e distrutto con contenente oggetto ed è quindi composizione.

Quindi, in questo caso del motore è un esempio di composizione e Battery un esempio di aggregazione.

#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;

}

Mi scuso se questo non è l'esempio migliore, ma si spera che illustra il punto principale.

Answer 2

Non sono sicuro di quello che si sta andando per qui, ma vorrei suggerire i seguenti esempi:

Aggregazione

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

Association (usi)

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

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