My real question is building about this question: Correct way to inherit from a virtual class with non-virtual parent.

Is my understanding right that within the situation that is referred to within the question, the 3 and 2 a part of new allotted object are seeping since they're not destructed?

Source:

#include <iostream>

struct One
{
    ~One() {
        std::cout << "~One()\n";
    }
};

struct Two : One
{
    virtual ~Two() {
        std::cout << "~Two()\n";
    }

    virtual void test() = 0;
};

struct Three : Two
{
    virtual ~Three() {
        std::cout << "~Three()\n";
    }

    virtual void test() {
        std::cout << "Three::test()\n";
    }
};

int main()
{
    Two* two = new Three;
    two->test();

    One* one = two;
    delete one;
}

Yes, that's correct. The phrase a memory leak is really a situation where you stand not able to remove something you produced (and whose lifetime you're therefore accountable for controlling).

Because the answers to that particular question indicate, delete one creates undefined behavior (which generally will most likely translate to some regular old memory leak, but things might be badly as nasal demons) since the runtime kind of the required object doesn't match its static (declared) type, and also the static type doesn't have an online destructor.

The relevant section in the C++ standard is that one:

§5.3.5/3: Within the first alternative (remove object), when the static kind of the operand differs from its dynamic type, the static type will be basics class from the operand’s dynamic type and also the static type shall possess a virtual destructor or even the behavior is undefined.

The answer is with the idea to declare all the destructors virtual, or otherwise to remove the objects via a pointer to One.