Exploring Virtual Destructors in C++/CLI

Posted by Joydip Kanjilal on December 24th, 2013

This article discusses what virtual methods are, why constructors cannot be virtual and why virtual
destructors are needed and the pitfalls if destructors are not defined virtual in some scenarios. The
concepts are discussed in a lucid language with plenty of code examples to illustrate the concepts.

A constructor is a method that has the same name as the name of the class and is invoked at the time
the class is instantiated. On the contrary, a destructor is a method that has the same name as the class
name but is prefixed with a tilde sign.
Here is an example that illustrates how a constructor and a destructor look.
1.
2.
3.
4.
5.
6.
7.
8.
9.

class Test
{
Test()
{
}
~Test()
{
}
};

Note that in C++ you cannot have access modifiers for constructors. Constructors in C++ cannot be
non-static also.

Virtual Methods

Now, what is a virtual method? Well, the virtual keyword is prefixed to a method of a class to
signify that the method is virtual. A virtual method is used to implement run-time polymorphism.
We now have a virtual method for the class Test shown below.
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.

class Test
{
Test()
{
}
virtual int Sample()
{
//Some code
}
~Test()
{
}
};

Note that for classes that have virtual methods, you would have a virtual table in memory. Virtual
tables are used to map the virtual methods at runtime. If a class has n virtual methods, there would be

one and only one virtual table in memory where the mapping information of all the n virtual methods
would be defined. Virtual tables are created at the time the constructor of the class is invoked. So,
you cannot have a virtual constructor as at the time the constructor is invoked, virtual table for the
class is not available in memory.
When you have a virtual method defined in a class, you have a virtual pointer made available to you
that points to the base address of the virtual table in memory. Consider the following code.
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.

class Base
{
public:
virtual void Sample()
{
printf("Hello from Base");
}
};
class Derived: public Base
{
public:
virtual void Sample()
{
printf("Hello from Derived");
}
};
int _tmain(int argc, _TCHAR* argv[])
{
Base *b = new Derived;
b->Sample();
getchar();
return 0;
}

1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.

class Base
{
public:
void Sample()
{
printf("Hello from Base");
}
};
class Derived: public Base
{
public:
void Sample()
{
printf("Hello from Derived");
}
};
int _tmain(int argc, _TCHAR* argv[])
{
Base *b = new Derived;
b->Sample();
getchar();
return 0;
}

When you execute the above code, the message "Hello from Derived" is displayed on the screen.
Now, if you omit the virtual keyword from each of the classes, i.e., the Base and also the Derived
classes, you would see that the message "Hello from Base" is displayed.

The reason is that when a base class pointer points to a derived class instance and a method on the
instance is called, the base version would always be invoked as the type of the pointer would be

considered. However, if the method is defined as virtual in both the base and the derived classes, the
context of the pointer would be considered. Hence the result.

Why do we Need Virtual Destructors?

A destructor can be virtual. Why should a destructor be virtual? Let's consider a scenario in which
there are two classes, a base class called Base and a derived class called Derived. Now, constructors
are invoked in the order of inheritance and destructors are invoked in the reverse order of
inheritance. So, in this example, the constructor of the Base class would be invoked followed by the
Derived class constructor. So, the Derived class destructor would be invoked followed by the Base
class destructor at the time when the object goes out of the scope or is destroyed.

Now, suppose you create an instance of the Derived class using a Base class pointer as we did earlier
in this article. When you delete the pointer object using the delete keyword, the destructor of the
Base class would be called and the destructor of the Derived class would simply be ignored.
The reason is that the destructor is simply another method and so when the delete keyword is used to
delete the pointer instance, the type of the pointer would be considered. And, because the type of the
pointer is of type Base, the destructor of the Base class would only be invoked. This might create
memory leaks as the instance of the derived class would still remain in memory even after the
pointer instance has been deleted/destroyed from memory. To avoid this potential memory leak,
virtual destructors are used.

Summary

Virtual destructors in C++ are used to avoid memory leaks when your class contains unmanaged
code, i.e., contains pointers or object handles to files, databases or other external objects. In this
article we explored virtual methods and virtual destructors in C++. Happy reading!

About the Author

Joydip Kanjilal is a Microsoft Most Valuable Professional in ASP.NET, speaker and author of
several books and articles. He has over 16 years of industry experience in IT with more than 10 years
in Microsoft .NET and its related technologies. Joydip was selected as MSDN Featured Developer of
the Fortnight (MSDN) a number of times and also as Community Credit Winner. His books include
the Entity Framework Tutorial, Sams Teach Yourself ASP.NET Ajax in 24 Hour, and ASP.NET Data
Presentation Controls Essentials. You can follow him on Twitter (@joydipkanjilal) or see more
about him on LinkedIn at http://in.linkedin.com/in/joydipkanjilal

Related Articles
Last.fm Open Sources C++ Moost Library Now Available
CppDepend Pro License for C\C++ open source project contributors

Copyright 2016 QuinStreet Inc. All Rights Reserved.