Question

I was wondering which part of my code will free a dynamically allocated, but static class member when this is not needed anymore. See the following code: classPrinter is shared among all A-objects and created when the first instance of class A will be created. Just to be sure: the classPrinter-object will automatically be destructed when exiting my program, right?

a.h

class A {
static B* classPrinter;
}

a.cpp

#include "a.h"
B A::classPrinter = new B();

A::A() { ...}

Answer 1

Just to be sure: the somePrinter-object will automatically be destructed when exiting my program, right?

Since this is C++, the answer is “No.” For everything allocated with new the corresponding delete must be called. If that doesn’t happen, the object leaks. But why allocate this dynamically at all? This

class A {
  static B classPrinter;
}

B A::classPrinter;

behaves like your code, except that classPrinter will be destructed at the end of the program.

However, you write that

classPrinter is shared among all A-objects and created when the first instance of class A will be created.

The code in your question doesn’t do this. If you want to do this, do something like this:

class A {
  static std::shared_ptr<B> classPrinter;
}

std::shared_ptr<B> A::classPrinter;

A::A()
{
  if(!classPrinter)
    classPrinter.reset(new B());
}

The smart pointer will make sure that the object gets deleted.