Effective C++: 绝对不要重定义一个继承而来的非虚函数.

2019独角兽企业重金招聘Python工程师标准>>>

主要涉及以下两点:
         1,派生类是不会继承基类中的 默认构造函数 拷贝构造函数 移动构造函数的。
         2，如果一个派生类同时有多个基类,且这些基类中存在参数列表与派生类中一致的构造函数，那么基类中的构造函数会被隐藏掉要使用using BaseClass::BaseClass.

 #include <iostream>

class Base{
 private:
  int b_;
  
  void private_function_in_base();
  
  public:
   Base()=default;
   
   Base(const int& b);
   
   virtual ~Base()=default; //作为基类必须把析构函数定义为virtual,再动态绑定的时候析构函数会自动调用其基类的虚函数，不然是不会的. 
   
   virtual void virtual_func()const noexcept;
   
   void func()const noexcept;
};

Base::Base(const int& b)
     :b_(b)
{
 //
}

void Base::virtual_func()const noexcept
{
 std::cout<<"virtual-function. In base: "<<this->b_<<std::endl;
}

void Base::func()const noexcept
{
 std::cout<<"ususlly function: "<<this->b_<<std::endl;
}

void Base::private_function_in_base()
{
 std::cout<<"private-function in Base: "<<std::endl;
}

class PureVirtualClass{ //注意类内部的纯虚函数，因此这是一个纯虚类，只能被继承不能作为类型使用.比如 PureVirtualClass p(这是错误的). 
 private:
  int p_;
  
  public:
   PureVirtualClass(const int& p):p_(p){}
   
   virtual void pure_function()=0; //可以提供定义也可以不提供. 
   
   virtual ~PureVirtualClass()=default;
};

class InheritBase final : public Base, public PureVirtualClass{
 private:
  int i_;
  
  public:
   using Base::Base;
   using PureVirtualClass::PureVirtualClass;
   
   InheritBase(const int& i);
   
   ~InheritBase()=default;
    
    virtual void virtual_func()const noexcept override; //c++11关键字(keyword)覆盖的意思. 
    
    virtual void pure_function()override;
    
    void func(const int& number); //该函数会隐藏基类中所有的同名函数，不管那些函数的参数列表是怎样的. 
    //但是如果隐藏了基类中的虚函数在动态调用的时候该函数还是可以被使用的. 
    
};

InheritBase::InheritBase(const int& i)
            :Base(i+1),
             PureVirtualClass(i+2),
             i_(i)
{
 //constructor;
}

void InheritBase::virtual_func()const noexcept
{
 std::cout<<"In InheritBase: "<<this->i_<<std::endl;
}

void InheritBase::pure_function()
{
 std::cout<<"there is a pure-virtual function"<<std::endl;
}

void InheritBase::func(const int& number)
{
 std::cout<<"number: "<<number<<std::endl;
}

int main()
{
 InheritBase i1(0);
 Base& b1 = i1;       //动态绑定. 
 
 b1.virtual_func();  //动态调用.  InheritBase::virtual_func();
 b1.func();         //           Base::func();
 
 i1.Base::func(); //这样就ok了. 强制调用从基类中继承来的函数. 
 //i1.func();   //这样是不行的.会报错. 
 i1.func(999); //该函数隐藏了Base中的func(). 
              //               InheritBase::func(const int&);
 
 
 return 0;
}

转载于:https://my.oschina.net/SHIHUAMarryMe/blog/645136