1.1.16.3 ctor in inheritance

• Subclass ctor will always call base class ctor.
  1. If subclass doesn’t define any ctor, compiler will implicitly define a default ctor, then this ctor will call base class default ctor.
  2. If subclass has a ctor, but the subclass’s ctor doesn’t explicitly call base specify ctor, ctor of subclass will call base default ctor.(without any parameter.) If base ctor only has specify ctor, no default ctor, produce compiler error.
  3. If you want explicitly call base specify ctor, use initialization list syntax.
  class base{ 
  public: 
    base();  //default ctor 
    base(int b); //specify ctor 
  private: 
    int b; 
  }; 
   
  class subclass: public base{ 
  subclass();  //default ctor 
  subclass(int s, int b); // specify ctor1 
  subclass(int s);     //specify ctor2 
  int s; 
  }; 
   
  subclass::subclass(int s, int b): base(b){ 
    m_s = s; 
  } 
  ////////////////////////////////////////// 
  subclass sc1(2,3); 
  //call specify ctor1, then 
  // explicit call base specify ctor 
   
  subclass sc2(2);  // implicit call base default ctor 
  subclass sc3;   // implicit call base default ctor 
  // if base has not default ctor, 
  //sc2 and sc3 will produce error. 
  }
• Constructor should NOT be virtual. When you use inheritance,
  1) The base-class object is constructed first
  2) The derived-class constructor can pass base-class information to a base-class constructor via a member initializer list or compiler call default base class ctor implicitly.
  3) The devived-class constructor should initialize the data member of it’s own
  
  //method 1: 
  DeriveClass::DeriveClass(int base_a, b): BaseClass(base_a){ 
     Derive_b = b      //this is the best method to do 
  }      // base_a is private member in base_class 
  ////////////////////// 
  //method 2: 
  DeriveClass::DeriveClass(int base_a, b){ 
    //it will call base_class default constructor. 
     // in this case, base_a is not assigned at all 
     Derive_b = b 
  } 
  ///////////////////// 
  //method 3: 
  DeriveClass::DeriveClass(int base_a, b) { 
  base_a = a    //It can be thought as a bad design. 
  //You can’t  access private base member data. 
  //base_a need to be public member data, 
  Derive_b = b 
  }
• For destructor:
  1. If a base class has a destuctor, but sub class doesn’t have, compiler will produce an implicit default destructor, and this implicit default destructor will call base class destuctor.
  2. If you define a subclass destructor, It will call base destructor automaticlly, you don’t need to call it explicitly.
  3. The question is, How can you make sure you sub class destructor will be called if you use a base class pointer or reference, answer is below:
• Base class destructor should be virtual? Why ? When you use base class pointer to a derive_class object, if the destructor is not virtual, It will only call base class destructor. No dynamic binding (polymorphism) is involved at all. Don’t call base desctructor explicitly, It will called automatically in the reverse order of construction. And you should give a base desctructor a definition, Or linker will report error it even you don’t call it in your source code.
• Assignment operator and copy ctor in inheritance:
  1. Default Assignment operator and copy constructor in derived class which are implicitly produced by compiler will call default base Assignment operator and copy constructor.
  2. If derived class has no new operation. Don’t need to define derived class Assignment operator and copy constructor, implicit one will call base one automatically
  3. If derived class has new operation. You have to define derived class Assignment operator and copy constructor, it will not invoke Assignment operator and copy constructor in base class any more. Inside, manually invoke base class Assignment operator and copy ctor Detail can be found in C++ primer p760. Syntax looks like below: see effective C++ Item 16.
  4. For copy ctor, just init list syntaxt. For assignment operator, use two different methods depends on if base class declare its own assignment operator(). Source code is below:
     DerivedClass::DerivedClass(const DerivedClass &dc): \ 
     BaseClass(dc){...}  //init list syntax here. 
      
     DerivedClass & DerivedClass::operator=(const DerivedClass &dc){ 
     BaseClass::operator=(dc); 
     // base class declare explicitly operator 
      
     ( (BaseClass&) *this ) = dc 
     //base class no explicitly operator 
     // change *this to BaseClass reference, 
     // if you change to BaseClass, It will call copy ctor. 
     }