C++ динамические объекты. Как определяется размер объекта во время выполнения?

Question

Я не понимаю одну вещь. Например, я объявляю класс А и класс В, который является потомком A:

class A { 
    public: 
     int a; 
} 

class B : public A { 
    public: 
     int b; 
} 

Очевидно, что если я создаю экземпляры А или В, их размер в памяти можно определить по типу.

A instanceA; // size of this will probably be the size of int (property a) 
B instanceB; // size of this will probably be twice the size of int (properties a and b) 

Но что делать, если я создаю динамические экземпляры, а затем освобожу их позже?

A * instanceAPointer = new A(); 
A * instanceBPointer = new B(); 

Они являются экземплярами различных классов, но программа будет рассматривать их как экземпляры класса А. Это хорошо при их использовании, но что об освобождении их? Чтобы освободить выделенную память, программа должна знать размер свободной памяти, не так ли?

Так что, если я пишу

delete instanceAPointer; 
delete isntanceBPointer; 

Как знать, программа, сколько памяти, начиная с адреса каждый указатель, указывающий на, он должен освободить? Поскольку очевидно, что объекты имеют разный размер, но программа считает их типа А.

Благодаря

Answer 1

Я собираюсь предположить, что вы знаете, как delete works.

Как delete знает, как очистить унаследованный экземпляр. Вот почему вы используете virtual destructor в контексте наследования, иначе у вас будет неопределенное поведение. В принципе, деструктор, как и любая другая функция virtual, вызывается через vtable.

Напомним также, что: Компилятор C++ неявно Деструктор родительский класс (ы) в вашем деструкторе

class A { 
    public: 
     int a; 
    virtual ~A(){} 
} 

class B : public A { 
    public: 
     int b; 
    ~B() { /* The compiler will call ~A() at the very end of this scope */ } 
} 

Вот почему это будет работать;

A* a = new B(); 
delete a; 

С помощью vtable, деструктор ~B() будет вызываться delete. Поскольку компилятор неявно вставляет вызов деструктора базового класса (ов) в производный класс (ы), деструктор A будет вызываться в ~B().

Answer 2

поведение не определено, если вы удаляете объект через указатель на базовый подобъекте и класс субобъекта делает не имеют виртуального деструктора.

С другой стороны, если у него есть виртуальный деструктор, тогда виртуальный диспетчерский механизм позаботится об освобождении правильного объема памяти за правильный адрес (т. Е. Для всего, самого производного объекта).

Вы можете найти адрес самого производного объекта самостоятельно, применив dynamic_cast<void*> к любому соответствующему указателю субобъектива базы. (См. Также this question.)

Answer 3

Чтобы освободить выделенную память, программа должна знать размер свободной памяти, не так ли?

Если рассматривать библиотеку C malloc и free, вы увидите, что нет необходимости указывать объем памяти освобождается при вызове free, даже если в этом случае free снабжен void* так есть нет способа сделать это. Вместо этого библиотеки распределения обычно либо записывают, либо могут вывести достаточное количество информации о предоставленной памяти, так что одного указателя достаточно для освобождения.

Это верно с C++ Deallocation подпрограмм: если базовый класс обеспечивает свой собственный static void operator delete(void*, std::size_t)и базового класс деструктор virtual, то он будет принят размером динамического типа. По умолчанию освобождение заканчивается на ::operator delete(void*), которому не будет предоставлен какой-либо размер: сами процедуры распределения должны знать достаточно, чтобы работать.

Есть множество способов процедуры распределения могут работать, в том числе:

• хранения размера из распределения

• выделяя аналогичные по размеру объекты из пула одинакового размера кусков, например что любой указатель на этот пул неявно относится к этому размеру куска