1.2.1.2 relationships between classes

• OOP has four relationships:
  1. Composition: Ownership, same life time, not change in the middle. Car and engine
  2. Aggregation: Ownership, maybe same life time, may change in the middle, People and toothbrush(same life time, changeable) Teacher and student( not same life time, changeable), Container and pointer(same life time, changeable).
  3. Associate: No Ownership, Includes as a member, different life time, person and father(Not Nullity), person and wife( Nullity)
  4. Dependency: No Ownership, Not Includes as a member, person and friend.
     1. Dependency definition: If class X’s member function argument is class Y, X is dependency of Y.
     2. Dependency definition extention: For a class X, all functions, including free functions, that both "Mention" X and "supplied with" X are logically part of X, because they form part of the interface of X.
• OOP example 1: If it’s a mother-son(Composition) relationship, and it’s compiler-given(not dynamic), just use member obj. Pay attention, If Engine has no default ctor, you have to use initialization list in car ctor. initialization list can be used to call base ctor.
  class Car{ 
  Engine eng; // member obj, not use pointer here. 
  Car(int carArg, int engArg): eng(engArg){} 
  }
• OOP example 2: If it’s an aggregation relationship, If has same life time, use uniqu_ptr. If you want to change, use uniqu_ptr reset function or move semantic from another uniqu_ptr. TootuBrush example, use unique_ptr.
  class Person{ 
  unique_ptr<Brush> unpbrush; 
   
  buyNewBrush(string &name){ 
     unpbrush.reset(new Brush()); 
  // you can’t use unpbrush= new Brush() 
  // unpbrush assignment only support( unique_ptr<T> &&); 
  // use reset, it will make original deleted automatically 
  } 
   
  // don’t need destructor any more. 
  }
• OOP example 3: if it’s wife-husband(Association) relationship, If you want to express Strong Not Nullity, use reference, such as Mother-Son association, You need to use initialization list to init mother. If Nullity, such as wife, just use raw pointer, weak_ptr or shared_ptr. Because no ownership involved, don’t use uniqu_ptr at all.
• OOP example 3-1: What’s different with raw pointer, weak_ptr or shared_ptr?
  class Man{ 
  Woman*  wife; // can be set to nullptr. 
  //maybe change or live longer than you. 
   
  weak_ptr<> 
   
  Woman &mother; //must give a mother in initial list 
  }
• OOP example 4: if it’s Dependency, such as friend relationship, Most of time, we just use pointer or reference as function parameter.
  class Man{ 
  lendMoney(Friend* mike); 
  } 
  //just use it in function. not a member of class.
• OOP example 5: Suppose Man and Computer is has-a relationship and same life time. Don’t use pointer or reference, just copy from a common computer, and maybe later you can customize your computer, and it will not effect common one. We can copy from commonComputer and init all Worker object. And this time use initialization list can improve efficiency.
  class Worker{ 
  Computer m_desktop; 
  Worker (Computer u): m_desktop(u){} 
  } 
   
  Computer commonComputer; 
  Worker Yan(commonComputer); 
  Worker Gang(commonComputer);
• OOP example6: Change a semantic, Unit may have a Bus, but owner policy tell us that bus can be shared by different unit. and life time policy tell us that bus and unit has separate life time. so here, we should use shared_ptr.
  class Unit{ 
  shared_ptr<Bus> shr_p_bus; 
  }