Title: Tokio, Source: own resources, Authors: Agnieszka and Michał Komorowscy
In C# it's simple, we use destructors a.k.a. finalizers almost never. The only one case when they are inevitable is the implementation of Disposable pattern. In C++ the situation is different because we don't have the automatic garbage collection. It means that if we create a new object with new keyword we have to destroy it later by using delete keyword. And if the object being deleted contains pointers to other objects created dynamically, they also need to be deleted. It's where destructors come to game. Here is an example with a class Node which models a binary tree. It's simplified and it is why all fields are public, don't do it in the production! Node::_count is a static field that I'm using to count created objects.
#include <stdexcept>
#include <iostream>
class Node {
public:
Node(int i) : _value(i) { Node::_count++; }
~Node() {
std::cout << " ~Node " << _value <<;
if(_left != nullptr) delete _left;
if(_right != nullptr) delete _right;
_count--;
}
static int _count;
int _value;
Node* _left = nullptr;
Node* _right = nullptr;
};
int Node::_count = 0;
Here is a testing code. If you run it you should see the result as follows: Existing nodes: 3 ~Node 1 ~Node 2 ~Node 3 Existing nodes: 0. We can see that all nodes have been deleted and that a destructor was executed 3 times.
int main()
{
Node* root = new Node(1);
root->_left = new Node(2);
root->_right = new Node(3);
std::cout << " Existing nodes: " << Node::_count;
delete root;
std::cout << " Existing nodes: " << Node::_count;
}
Now let's derived a new class from Node in the following way:
class DerivedNode : public Node {
public:
DerivedNode(int i) : Node(i) {
}
~DerivedNode() {
std::cout << " ~DerivedNode " << _value;
}
};
And modify a testing code a little bit in order to use our new class:
int main()
{
Node* root = new DerivedNode(1);
root->_left = new DerivedNode(2);
root->_right = new DerivedNode(3);
std::cout << " Existing nodes: " << Node::_count;
delete root;
std::cout << " Existing nodes: " << Node::_count;
}
The expectation is that ~DerivedNode destructor should be called together with the base class destructor ~Node. However, if you run the above code you'll notice see that it's not true i.e. you'll see the same result as earlier. To explain what's going look at the C# code below and answer the following question: Why I see "I'm A" if I created an instance of class B
public class A
{
public void Fun() { Console.WriteLine("I'm A"); }
}
public class B: A
{
public void Fun() { Console.WriteLine("I'm B"); }
}
A a = new B();
a.Fun();
I hope that it's not a difficult question. The answer is of course because Fun is not a virtual method. In C++ we have the same situation. Now you may say "Wait a minute, but we're talking about destructors not methods". Ya, but destructors are actually a special kind of methods. The fix is simple we just need to use a concept completely unknown in C# i.e. a virtual destructor.
virtual ~Node() {
...
}
This time the test code will give the following result Existing nodes: 3 ~DerivedNode 1 ~Node 1 ~DerivedNode 2 ~Node 2 ~DerivedNode 3 ~Node 3 Existing nodes: 0 .
orcid.org/0000-0002-6838-2135