Почему при создании класса у абстракных классов по иерархии пусто в _vptr ?

#pragma once
 
/*
 * Базовый класс для всех контейнеров
 */
 
#include <cstring>
#include "MemoryManager.h"
 
/*
 * Базовый класс для всех абстрактных контейнеров
 */
class Container {
protected:
    MemoryManager &_memory;
 
public:
    /*
     * Базовый класс для исключений, которые запускает контейнер
     */
    struct Error {
        char msg[256];
 
        //Error(const char *err_msg) { strcpy(msg, err_msg); }
    };
 
    class Iterator {
    public:
        /*
         * Возврашает явно указатель на элемент, на который указывает итератор в
         * данный момент.
         * Неявно возвращает размер данных
         */
        virtual void *getElement(size_t &size) = 0;
 
        /*
         * Возвращает true, если есть следующий элемент, иначе false.
         */
        virtual bool hasNext() = 0;
 
        /*
         * Переход к следующему элементу.
         */
        virtual void goToNext() = 0;
 
        /*
         * Проверка на равенство итераторов.
         */
        virtual bool equals(Iterator *right) = 0;
    };
 
    Container(MemoryManager &mem) : _memory(mem) { }
 
    /*
     * Функция возвращает значение, равное количеству элементов в контейнере.
     */
    virtual int size() = 0;
 
    /*
     * Функция возвращает значение, равное максимальной вместимости контейнера в
     * байтах.
     */
    virtual size_t max_bytes() = 0;
 
    /*
     * Функция возвращает указатель на итератор, указывающий на первый найденный в
     * контейнере элемент. Если элемент не найден, возвращается пустой указатель.
     */
    virtual Iterator *find(void *elem, size_t size) = 0;
 
    /*
     * Удаление всех элементов из контейнера.
     */
    virtual void clear() = 0;
 
    /*
     * Создание итератора, соответствующего данному типу контейнера.
     */
    virtual Iterator *newIterator() = 0;
 
    /*
     * Функция возвращает указатель на итератор, указывающий на первый элемент
     * контейнера. Если контейнер пустой, возвращается нулевой указатель.
     */
    virtual Iterator *begin() = 0;
 
    /*
     * Функция возвращает указатель на итератор, указывающий позицию за последним
     * элементом контейнера. Если контейнер пустой, возвращается нулевой
     * указатель.
     */
    virtual Iterator *end() = 0;
 
    /*
     * Eсли контейнер пуст возвращает true, иначе false
     */
    virtual bool empty() = 0;
 
    /*
     * Удаление элемента из позиции, на которую указывает итератор iter.
     * После удаления итератор указывает на следующий за удаленным элемент.
     */
    virtual void remove(Iterator *iter) = 0;
};

#pragma once
 
#include "Container.h"
 
/*
 * Базовый класс для некоторой группы абстрактных контейнеров.
 */
class GroupContainer : public Container {
public:
    GroupContainer(MemoryManager &mem) : Container(mem) { }
};

#pragma once
 
#include <stddef.h>
 
/*
 * Базовый класс менеджера памяти
 */
 
class MemoryManager {
private:
    size_t _size;
 
public:
    MemoryManager(size_t sz) : _size(sz) { }
 
public:
    size_t size() { return _size; }
 
    virtual void *allocMem(size_t sz) = 0;
 
    virtual void freeMem(void *ptr) = 0;
};

#pragma once
 
#include "GroupContainer.h"
#include "MemoryManager.h"
 
/*
 * Абстрактный класс: дерево
 */
class AbstractTree : public GroupContainer {
public:
    class Iterator : public Container::Iterator {
    public:
        /*
         * Переход к родительской вершине. Возвращает false если текущая вершина -
         * корень или end().
         */
        virtual bool goToParent() = 0;
 
        /*
         * Переход к дочерней вершине № child_index. Возвращает false если дочерней
         * вершины с таким номером нет.
         */
        virtual bool goToChild(int child_index) = 0;
    };
 
    /*
     * конструктор
     */
    AbstractTree(MemoryManager &mem) : GroupContainer(mem) { }
 
    /*
     * деструктор
     */
    virtual ~AbstractTree() { }
 
    /*
     * Добавление элемента как дочернюю вершину № child_index вершины, на которую
     * указывает итератор. В случае успешного добавления функция возвращает
     * значение 0, в случае неудачи 1.
     */
    virtual int insert(Iterator *iter, int child_index, void *elem,
                       size_t size) = 0;
 
    /*
     * Удаление вершины, на которую указывает итератор. Если leaf_only==1 и
     * вершина не является листом, возвращает false
     * !!! Примечание: метод remove удаляет вершину вместе со всеми ее потомками
     */
    virtual bool remove(Iterator *iter, int leaf_only) = 0;
};

#pragma once
 
#include "Tree.h"
 
enum color {
    RED, BLACK
};
 
/*
 * Класс узел
 */
#pragma pack(push, 1)
class Node {
    int *data;
    color color_;
    Node *left;
    Node *right;
    Node *parrent;
 
public:
    Node(int *data)
            : left(NULL), right(NULL), parrent(NULL), color_(RED), data(data) { };
 
    ~Node() {};
 
public:
    friend class RBtree;
};
#pragma pop
 
/*
 * Класс дерево
 */
class RBtree : public AbstractTree {
public:
    /*
     * Класс итератор дерева
     */
    class Iterator : public AbstractTree::Iterator {
        RBtree *Rbtree;
 
    public:
        Node *cur;
 
    public:
        Iterator(Node *n, RBtree *rb) : cur(n), Rbtree(rb) { };
 
        ~Iterator() { };
 
        /*
         * Виртуальные функции
         */
    public:
        // Container
        void *getElement(size_t &size);          // done! ok
        bool hasNext();                          // done! ok
        void goToNext();                         // done! ok
        bool equals(Container::Iterator *right); // done! ok
 
        // Tree
        bool goToParent();               // done! ok
        bool goToChild(int child_index); // done! ok
    };
 
private:
    Node *root;
    Node *NIL;
 
public:
    RBtree(MemoryManager &mem);
 
    ~RBtree() { };
 
    /*
     * Пользовательские функции
     */
public:
    void tree_insert(Node *n);
 
    void left_rotate(Node *n);
 
    void right_rotate(Node *n);
 
    void rb_insert(Node *n);
 
    Node *rb_delete(Node *n);
 
    void rb_delete_fixup(Node *n);
 
    Node *tree_successor(Node *n);
 
    Node *tree_predecessor(Node *n);
 
    void inorder_tree_walk(Node *n);
 
    void inorder_tree_walk_count(Node *n, int *count);
 
    void inorder_tree_walk_delete(Node *n);
 
    void inorder_tree_walk_delete_all_nodes(Node *n);
 
    Node *iterative_tree_search(Node *n, int *data);
 
    Node *tree_minimum(Node *n);
 
    Node *tree_maximum(Node *n);
 
    /*
     * Виртуальные функции
     */
public:
    // Container
    int size();                              // done! ok
    size_t max_bytes();                      // done! ok
    Iterator *find(void *elem, size_t size); // done! ok
    void clear();                            // done! ok
    Iterator *newIterator();                 // done! ok
    Iterator *begin();                       // done! ok
    Iterator *end();                         // done! ok
    bool empty();                            // done! ok
    void remove(Container::Iterator *iter);  // done! ok
 
    // Tree
    int insert(AbstractTree::Iterator *iter, int child_index, void *elem,
               size_t size);                                  // done! ok
    bool remove(AbstractTree::Iterator *iter, int leaf_only); // done! ok
};