Destructors And Interfaces#

Destructor, Straightforward Usage #

Lets say one of our sensor implementations allocates resources (e.g. by using new)
⟶ Destructor needed!
Called at exit from function

code/destructor-nonvirtual/sensors.h#

#include <iostream>

class Sensor
{
public:
    virtual double get_value() const = 0;
};

class MySensor : public Sensor
{
public:
    MySensor(double value)
    : _value(new double{value}) {}                     // <-- allocation
    ~MySensor()
    {
        std::cout << "MySensor::~MySensor()" << std::endl;
        delete _value;                                 // <-- deallocation
    }
    double get_value() const override
    {
        return *_value;
    }
private:
    double* _value;
};

code/destructor-nonvirtual/main.cpp#

#include "sensors.h"
#include <iostream>

int main()
{
    MySensor ms{37.3};
    return 0;                                          // <-- destructor called
}

$ ./code/destructor-nonvirtual/cxx-inher-oo-destructor-straightforward
MySensor::~MySensor()

Calling Destructor Through Base Class Pointer #

What if MySensor object is
- allocated on the heap?
- only a Sensor* is used to represent it? (Polymorphic usage)
- freed using a Sensor*?

code/destructor-nonvirtual/base-delete.cpp#

#include "sensors.h"
#include <iostream>

int main()
{
    Sensor* s = new MySensor{37.3};
    delete s;
    return 0;
}

$ ./code/destructor-nonvirtual/cxx-inher-oo-destructor-base-delete
... remains silent ...

Virtual Destructor (Destructors Are Special)#

Obviously, dynamic dispatch is needed for destructor too
Compiler inserts code to call all destructors along the inheritance chain, up to the very base
⟶ Cannot be virtual
⟶ Empty virtual

Solution: Empty Virtual Destructor #

code/destructor-virtual-nonempty/sensors.h#

#include <iostream>

class Sensor
{
public:
    virtual ~Sensor() = default;                       // <-- empty!
    virtual double get_value() const = 0;
};

class MySensor : public Sensor
{
public:
    MySensor(double value)
    : _value(new double{value}) {}
    ~MySensor() override
    {
        std::cout << "MySensor::~MySensor()" << std::endl;
        delete _value;
    }
    double get_value() const override
    {
        return *_value;
    }
private:
    double* _value;
};

code/destructor-virtual-nonempty/main.cpp#

#include "sensors.h"
#include <iostream>

int main()
{
    Sensor* s = new MySensor{37.3};
    delete s;                                          // <-- base pointer used to free derived object
    return 0;
}

$ ./code/destructor-virtual-nonempty/cxx-inher-oo-destructor-virtual-nonempty
MySensor::~MySensor()