在C++中调用构造函数/析构函数中的虚方法-yiteyi-C++库

先决条件： C++中的虚函数从构造函数或析构函数调用虚拟函数在大多数情况下被认为是危险的，必须尽可能避免。所有C++实现都需要调用当前构造函数中层次结构定义的函数的版本，而不是进一步调用。可以在构造函数中调用虚函数。这些对象是从“派生之前的基础”开始构建的。

null

CPP

                         // CPP program to illustrate                       
                         // calling virtual methods in                       
                         // constructor/destructor                       
                         #include<iostream>                       
                         using                                     namespace                                     std;                       
           
                         class                                     dog                       
                         {                       
                         public                                     :                       
                                                 dog()                       
                                                 {                       
                                                 cout<<                                     "Constructor called"                                     <<endl;                       
                                                 bark() ;                       
                                                 }                       
           
                                                 ~dog()                       
                                                 {                       
                                                 bark();                       
                                                 }                       
           
                                                 virtual                                     void                                     bark()                       
                                                 {                       
                                                 cout<<                                     "Virtual method called"                                     <<endl;                       
                                                 }                       
           
                                                 void                                     seeCat()                       
                                                 {                       
                                                 bark();                       
                                                 }                       
                         };                       
           
                         class                                     Yellowdog :                                     public                                     dog                       
                         {                       
                         public                                     :                       
                                                 Yellowdog()                       
                                                 {                       
                                                 cout<<                                     "Derived class Constructor called"                                     <<endl;                       
                                                 }                       
                                                 void                                     bark()                       
                                                 {                       
                                                 cout<<                                     "Derived class Virtual method called"                                     <<endl;                       
                                                 }                       
                         };                       
           
                         int                                     main()                       
                         {                       
                                                 Yellowdog d;                       
                                                 d.seeCat();                       
                         }                       

输出：

Constructor calledVirtual method calledDerived class Constructor calledDerived class Virtual method calledVirtual method called

说明：

dog类中的bark方法在构造函数和析构函数中都被调用。
创建Yellowdog对象时，会调用dog的构造函数，然后调用Yellowdog的构造函数，调用析构函数的顺序与调用析构函数的顺序相反。
虽然bark方法是虚拟方法，但是当它被调用时 在构造函数内部，它将表现为非虚方法，因为在dog（base）类的构造函数中 在上面的代码中被调用，Yellowdog（派生）类那时还没有构造。
因此，调用对象尚未构造的类的成员函数是危险的，编译器会调用巴克方法的dog类版本。析构函数也是一样，当Yellowdog的对象“d”被销毁时，首先调用Yellowdog类的析构函数，然后调用dog类的析构函数，但此时Yellowdog已经被销毁，因此调用了dog类版本的bark。

注：强烈建议避免从构造函数/析构函数调用虚拟方法。虚拟函数测验本文由 亚什·辛拉 .如果你喜欢GeekSforgek，并想贡献自己的力量，你也可以使用写极客。组织或者把你的文章寄去评论-team@geeksforgeeks.org.看到你的文章出现在Geeksforgeks主页上，并帮助其他极客。如果您发现任何不正确的地方，或者您想分享有关上述主题的更多信息，请写下评论。

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

THE END

技术文章