In this post, I will introduce rules related to constructors and destructors of classes which has virtual functions.<\/p>\n\n\n\n
In C++, Virtual functions allow for the choice of member function calls to be determined at run time based on the dynamic type of the object that the member function is being called on, which supports OOP practices commonly associated with object inheritance and function overriding.<\/p>\n\n\n\n
Firstly you should notice that in C++ Standard<\/a>,<\/p>\n\n\n\n In many design patterns, people will implement classes which are inherited from a virtual interface. Customers might use pointers of the interface which point to the derived instance. It comes to the problem.<\/p>\n\n\n\n When customers want to delete an instance of a derived class through a pointer to base class, if base’s destructor is not virtual, Calling virtual functions from a constructor or destructor is dangerous and should be avoided whenever possible. All C++ implementations should call the version of the function defined at the level of the hierarchy in the current constructor and no further.<\/p>\n\n\n\n D attempts to overrides B’s f. And the programmer knows that the order of construction is from base to derived. He then naively thinks once f is overridden, B’s constructor will actually call D’s f. Which is great. Then you may ask when my base class\u2019s constructor calls a virtual function on its this object, why doesn\u2019t my derived class\u2019s override of that virtual function gets invoked. Because it is dangerous<\/strong>.<\/p>\n\n\n\n Consider what would happen if the rule were different so that D::f() was called from B::B(): Because the constructor D::D() hadn\u2019t yet been run, D::f() would try to assign its argument to an uninitialized string s. The result would most likely be an immediate crash.<\/p>\n\n\n\nIf a class has no user-declared destructor, a destructor\nis implicitly declared as defaulted. An implicitly declared\ndestructor is an inline public member of its class.<\/code><\/pre>\n\n\n\nclass Base \n{\n \/\/ an interface consists of some virtual methods\n};\n\nclass Derived : public Base\n{\n ~Derived()\n {\n \/\/ Do some important cleanup\n }\n};<\/code><\/pre>\n\n\n\ndelete b<\/code> has undefined behavior. In most implementations, the call to the destructor will be resolved like any non-virtual code, meaning that the destructor of the base class will be called but not the one of the derived class, resulting in a resources leak.<\/p>\n\n\n\nGolden Rule 2<\/h4>\n\n\n\n
class B {\n public:\n B(const string& ss) { cout << \"B constructor\\n\"; f(ss); }\n virtual void f(const string&) { cout << \"B::f\\n\";}\n };\n class D : public B {\n public:\n D(const string & ss) :B(ss) { cout << \"D constructor\\n\";}\n void f(const string& ss) { cout << \"D::f\\n\"; s = ss; }\n private:\n string s;\n };\n int main()\n {\n D d(\"Hello\");\n }<\/code><\/pre>\n\n\n\n
However, the result is<\/p>\n\n\n\nB constructor\nB::f\nD constructor<\/code><\/pre>\n\n\n\n