1.2.1.3 Has-a relationship

• Interestingly, You can use 1)private inheritance, 2)composition and 3)template three methods to describe has-a relationship.
• Private and protect inheritances are used to implement has-a relationship. Introduce their access policy in inheritance:
  1. None of the derived classes can access anything that is private in B.
  2. In D_priv, the public and protected parts of B are private.
  3. In D_prot, the public and protected parts of B are protected. Protect used in three generation inheritance. By protected Inheritance, grandfather member become protected member in father, so Grandson can still use grandfather’s members.
  4. In D_publ, the public parts of B are public and the protected parts of B are protected (D_publ is-a-kind-of-a B).
  5. Class UserClass can access only the public parts of B, which "seals off" UserClass from B.
  class B                    { /*...*/ }; 
  class D_priv : private   B { /*...*/ }; 
  class D_prot : protected B { /*...*/ }; 
  class D_publ : public    B { /*...*/ }; 
  class UserClass            { B b; /*...*/ };
• To make a public member of B public in D_priv or D_prot, state the name of the member with a B:: prefix. E.g., to make member B::f(int,float) public in D_prot, you would say:
  class D_prot : protected B { 
  public: 
    using B::f;  // Note: Not using B::f(int,float) 
  };
• In short, composite uses object names to invoke a method, whereas private Inheritance uses the class name and scope resolution operator Instead. If you need the base class itself„ use a type case (const string&) * this; detail can be seen in C++ primer, P800
• If you want to reuse string code in class student(also means has-a relationship, student has a string name) you have two options, The first is composition, the second is private inheritance. See below:
  class Student{ // 1) use composition. 
  int getNameLen(); 
  private: 
  ____________string m_name; 
  vector<double> score; 
  }; 
  int Student::getNameLen(){ 
    return m_name.length(); 
  }
  class Student: ___________________________private string, private std::vector<double>{ 
  int getNameLen(); 
  // We don’t need private memeber data any more 
  } 
   
  int Student::getNameLen(){ 
    return string::length(); 
    //use class name and scope-resolution operator 
  } 
  const string& Student::getName(){ 
    return (const string&) *this; 
  }
• Prefer composition, use private inheritance when you have to. Reusing by private inheritance is weird in syntax and difficult to understand. One exception is you have to access string or vector<T> protect member function, at this time, you MUST use private inheritance.
• By now, I want to not only reuse class A, I also want to make a class adaptable. or make it possible to select different algorithms from the outside. An example is to replace brakes of a car (at runtime) Intend to pass Car around to non-template functions There are three options.
  1. Version 1: Abstract base class, In fact, consider same life time and composition relationship, Using Brake obj directly is better. But you want to have runtime polymorphism at the same time, So have to use pointer or reference. Here you can use smart pointer(uniqu_ptr).
     class Brake { 
     public: virtual void stopCar() = 0; 
     }; 
      
     class BrakeWithABS : public Brake { 
     public: void stopCar() { ... } 
     }; 
      
     class Car { 
       Brake* _brake; 
     public: 
       Car(Brake* brake) : _brake(brake) { brake->stopCar(); } 
     };
  2. Version 2a: Template
     template<class Brake> 
     class Car { 
       Brake brake; 
     public: 
       Car(){ brake.stopCar(); } 
     };
  3. Version 2b: Template and private inheritance
     template<class Brake> 
     class Car : private Brake { 
       using Brake::stopCar; 
     public: 
       Car(){ Brake::stopCar(); } 
     };
• I would generally prefer version 1 using the runtime polymorphism, because it is still flexible, and All Car have the same type. In template implementation, Car<Opel> is another type than Car<Nissan>. If your goals are great performance while using the brakes frequently, i recommend you to use the templated approachstatic binding. By the way, this is called policy based design.
• Another example about policy based design is std::map, you can input a functor type, use to compare two elements inside map. At this time, because your host(std::map) is template, you have to use policy based design.