Virtual destructor moves object out of rodata section

Question

I have a large number of static constant objects which are constructed with a constexpr constructor, so they are immediately stored in the final binary without any constructor call.

Since I'm working on a low RAM system (STM32 MCU), I want to reduce the memory footprint of these objects and since they are constant, store them in the .rodata section instead. The compiler managed this without a problem.

But, now that I added a virtual destructor to the base class in order to remove compiler warnings, the objects are stored in the .data section instead.

Of course, I could use some #pragma to remove the compiler warnings for the base class specifically and remove the virtual destructor, but I want to know if there is a cleaner solution to this.

Minimalism code showcasing the problem:

class Object {
    int value;
public:
    constexpr Object(int param) 
    : value(param) {}

    virtual int getValue() const = 0;

    virtual ~Object() = default; // This line causes problems
};

class Derived : public Object {
    volatile int otherValue;
public:
    constexpr Derived(int param1, int param2) 
    : Object(param1), otherValue(param2) {}

    int getValue() const override { return otherValue; }
};


const Derived instance(1,2);

int main() {
    return instance.getValue();
}

Also, here is a CompilerExplorer to compare with and without the virtual destructor: https://godbolt.org/z/M5G7LO

Answer 1

The moment you declare a virtual method, you add a non-constant pointer to your class that points to the virtual table of that class. This pointer will first be initialized to Object's virtual table, and then continue to change to the derived classes' virtual pointers throughout the constructor chain. It will then change again during the destructor chain and roll-back until it points to Object's virtual table. That would mean that your object can no longer be a pure read-only object and must move out of .rodata.

A cleaner solution would either be to omit any virtual function in your classes, or to avoid inheritence entirely and use templates to replace the required virtual function calls with compile time calls.