C++中虚拟函数可以是私有的吗？-yiteyi-C++库

在C++中，虚函数可以是私有的，可以由派生类重写。例如，以下程序编译并运行良好。

null

C++

                         #include <iostream>                       
           
                         class                                     base                       
                         {                       
                         public                                     :                       
                                   
                                                 // default base constructor                       
                                                 base() { std::cout <<                                     "base class constructor"                                     ; }                       
                                   
                                                 // virtual base destructor                       
                                                 // always use virtual base                       
                                                 // destructors when you know you                       
                                                 // will inherit this class                       
                                                 virtual                                     ~base()                       
                                                 {                       
                                                 std::cout <<                                     "base class destructor"                                     ;                       
                                                 }                       
                                                 // public method in base class                       
                                                 void                                     show()                       
                                                 {                       
                                                 std::cout <<                                     "show() called on base class"                                     ;                       
                                                 }                       
                                   
                                                 // public virtual function in base class,                       
                                                 // contents of this function are printed when called                       
                                                 // with base class object when called with base class                       
                                                 // pointer contents of derived class are printed on                       
                                                 // screen                       
                                                 virtual                                     void                                     print()                       
                                                 {                       
                                                 std::cout <<                                     "print() called on base class"                                     ;                       
                                                 }                       
                         };                       
           
                         class                                     derived :                                     public                                     base {                       
                         public                                     :                       
                                                 // default derived constructor                       
                                                 derived()                       
                                                 : base()                       
                                                 {                       
                                                 std::cout <<                                     "derived class constructor"                                     ;                       
                                                 }                       
                                                 // virtual derived destructor                       
                                                 // always use virtual destructors                       
                                                 // when inheriting from a                       
                                                 // base class                       
                                                 virtual                                     ~derived()                       
                                                 {                       
                                                 std::cout <<                                     "derived class destructor"                                     ;                       
                                                 }                       
           
                         private                                     :                       
                                                 // private virtual function in derived class overwrites                       
                                                 // base class virtual method contents of this function                       
                                                 // are printed when called with base class pointer or                       
                                                 // when called with derived class object                       
                                                 virtual                                     void                                     print()                       
                                                 {                       
                                                 std::cout <<                                     "print() called on derived class"                                     ;                       
                                                 }                       
                         };                       
           
                         int                                     main()                       
                         {                       
                                                 std::cout <<                                     "printing with base class pointer"                                     ;                       
                                   
                                                 // construct base class pointer with derived class                       
                                                 // memory                       
                                                 base* b_ptr =                                     new                                     derived();                       
                                   
                                                 // call base class show()                       
                                                 b_ptr->show();                       
                                   
                                                 // call virtual print in base class but it is overridden                       
                                                 // in derived class also note that print() is private                       
                                                 // member in derived class, still the contents of derived                       
                                                 // class are printed this code works because base class                       
                                                 // defines a public interface and drived class overrides                       
                                                 // it in its implementation                       
                                                 b_ptr->print();                       
           
                                                 delete                                     b_ptr;                       
                         }                       

输出

printing with base class pointerbase class constructorderived class constructorshow() called on base classprint() called on derived classderived class destructorbase class destructor

在上面的程序中没有什么需要注意的。 b_ ptr 是一个指针基础键入并指向衍生类对象。什么时候 ptr->print（）叫做打印 () 属于衍生被处决了。

这段代码之所以有效，是因为基类定义了一个公共接口，而派生类在其实现中重写了它，即使派生类有一个私有虚函数。如果您发现任何不正确的地方，或者您想分享有关上述主题的更多信息，请写评论

文章版权归作者所有，未经允许请勿转载。

THE END