1.2.1.5 virtual function and override

• Only virtual function come into vtbl. Friend can’t be virtual function, because it’s not a member of class.
• When a method is declared virtual in a base class, it is automatically virtual in the derived class, but it is a good idea to explicitly declare it by using the keyword virtual in the derived class declarations too.
• Almost all the base class has virtual function, if a class doesn’t contain a virtual function, It is an indication that it is not meant to be used as a base class
• Don’t rewrite non-virtual base member function, see effective c++
• For overriding to occur, several requirements must be met:
  1. The base class function must be virtual.
  2. The base and derived function names must be identical (except in the case of destructors).
  3. The parameter types of the base and derived functions must be identical.
  4. The constness of the base and derived functions must be identical.
  5. The return types and exception specifications of the base and derived functions must be compatible.
  6. To these constraints, which were also part of C++98, C++11 adds one more: The functions’ reference qualifiers must be identical.
• reference qualifier explain:
  class Widget { 
  public: 
  void doWork() &; // this version of doWork applies 
  // only when *this is an lvalue 
  void doWork() &&; // this version of doWork applies 
  }; // only when *this is an rvalue 
   
  Widget makeWidget(); // factory function (returns rvalue) 
  Widget w; // normal object (an lvalue) 
   
  w.doWork(); 
  // calls Widget::doWork for lvalues (i.e., Widget::doWork &) 
  makeWidget().doWork(); 
  // calls Widget::doWork for rvalues (i.e., Widget::doWork &&)
• Any small error will not real override base virtual function. but creating a new virtual method with a different signature. such as examples below.
  class Base { 
  public: 
  virtual void mf1() const; 
  virtual void mf2(int x); 
  virtual void mf3() &; 
  void mf4() const; 
  }; 
  class Derived: public Base { 
  public: 
  virtual void mf1(); 
  virtual void mf2(unsigned int x); 
  virtual void mf3() &&; 
  void mf4() const; 
  };
• override specifier should be used in derived class member funcition used to check if they are match with member function in base class.
  struct A{ 
      virtual void foo(); 
      void bar(); 
  }; 
   
  struct B : A{ 
      void foo() override; // OK: B::foo overrides A::foo 
      void bar() override; // Error: A::bar is not virtual 
  }
• Use final in Base class, to stop sub class override.
  class Base{ 
  virtual void method1() final; 
  }