Virtual Destructors

C++ allows classes to inherit from other classes.

In some cases, such as this example, this can lead to memory leaks:

  1. class ABase {
  2. public:
  3.   ~ABase() {}
  4. };
  6. class A : public ABase {
  7.   std::string *value_;
  8. public:
  9.   A() : value_(new std::string) {}
  10.   ~A() { delete value_; }
  11. };
  13. void do_something() {
  14.   ABase *instance = new A();
  15.   //...
  16.   delete instance;
  17. }

So here we allocate a pointer to A, assign it to “instance” which is of type ABase, do something with it and finally delete it. It looks fine but we just leaked memory! When we called “delete instance” the code invoked the destructor ~ABase() and NOT the destructor ~A() . And value_ was not deleted and the memory leaked. Even if we’d used a scoped pointer to wrap value_ it would still have leaked.

The code should have said

  1. class ABase {
  2. public:
  3.   virtual ~ABase() {}
  4. };

The compiler didn’t care our code was in error. It just allowed us to leak for the sake of a missing keyword.

How Rust helps

Rust also does not use inheritance so problems like ABase above cannot exist. In Rust ABase would be declared as a trait that A implements.

  1. trait ABase {
  2.   //...
  3. }
  5. struct A {
  6.   value: String,
  7. }
  9. impl ABase for A {
  10.   //...
  11. }

Rust also allows our struct to implement another trait called Drop which is equivalent to a C++ destructor.

  1. impl Drop for A {
  2.   fn drop(&mut self) {
  3.     println!("A has been dropped!");
  4.   }
  5. }

It allows our code to do something during destruction such as to free an open resource, log a message or whatever.