Cómo agregación indican en términos de un código de programación?

Question

Yo sé de Asociación y Agregación y Composición y Generalización lo que son por definición. herencia se "es una" relación y composición se "tiene una" relación.

Class A {
}

Class B extends A { // this is Generalization
}

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

Ahora mi pregunta es cómo se muestra la agregación y la Asociación simple en términos de código de programación. ?

Answer 1

Me sospecha que su verdadera cuestión tiene que ver con la composición frente a la agregación. Se puede pensar en la diferencia en términos de propiedad, pero la distinción real (por mi dinero) es lo que controla el ciclo de vida del objeto agregado.

En la composición. cuando el objeto compuesto se destruye sus partes o clases contenidas son destruidas junto con él. Con la agregación, la vida útil del objeto contenido puede ser independiente del objeto que contiene. En codigo. esto se reduce a si el objeto componente se especifica por valor o referencia. Agregación tiene que ser hecho por referencia (o puntero como en el ejemplo). Si se hace por el valor de la parte componente se vaya fuera de alcance y ser destruido con que contiene objeto y es por lo tanto la composición.

Así que en este caso es un ejemplo de motor de la composición y de la batería un ejemplo de agregación.

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

}

Disculpas si este no es el mejor ejemplo, pero es de esperar que ilustra el punto principal.

Answer 2

No estoy seguro exactamente lo que vamos a dar aquí, pero yo sugeriría los siguientes ejemplos:

Agregación

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

Association (usos)

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

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