Какие знаешь особенности вызова виртуальной функции из деструктора?

Особенности вызова виртуальной функции из деструктора

Вызов виртуальных функций из деструктора — это опасная практика, которая часто приводит к критическим ошибкам и undefined behavior. Это один из самых коварных подвохов C++, требующий понимания порядка уничтожения объектов.

Суть проблемы

При уничтожении объекта производного класса сначала вызывается деструктор производного класса, затем деструктор базового. Во время выполнения деструктора базового класса объект больше не является объектом производного класса — это важный момент.

class Base {
public:
    virtual void doSomething() {
        std::cout << "Base::doSomething\n";
    }
    
    virtual ~Base() {
        doSomething();  // ⚠️ Вызовет Base::doSomething, не Derived!
    }
};

class Derived : public Base {
public:
    void doSomething() override {
        std::cout << "Derived::doSomething\n";
    }
    
    ~Derived() {
        std::cout << "Derived destructor\n";
    }
};

int main() {
    {
        Derived d;
    }  // Вывод:
       // Derived destructor
       // Base::doSomething (НЕ Derived::doSomething!)
    
    return 0;
}

Почему так происходит?

В каждом объекте хранится виртуальная таблица (vtable), которая указывает на методы класса. Во время уничтожения:

1. Вызывается деструктор Derived — vtable всё ещё указывает на Derived
2. Вызывается деструктор Base — компилятор меняет vtable на Base::vtable
3. Любой virtual вызов теперь разрешается к Base, не Derived

// Упрощённое представление
struct Base {
    vtable* vptr;  // Указатель на таблицу методов
    
    ~Base() {
        this->vptr = &Base::vtable;  // ← Меняем таблицу на Base!
        doSomething();  // Вызовет Base::doSomething
    }
};

Риск 1: Доступ к неинициализированным членам

class Base {
public:
    virtual std::string getName() { return "Base"; }
    
    virtual ~Base() {
        std::cout << getName() << "\n";  // Может быть опасно!
    }
};

class Derived : public Base {
public:
    Derived() : resource_(new std::string("resource")) {}
    
    ~Derived() {
        delete resource_;  // Удаляем ресурс
    }
    
    std::string getName() override {
        return *resource_;  // ⚠️ resource_ уже удалён!
    }
    
private:
    std::string* resource_;
};

int main() {
    {
        Derived d;  // Вывод может быть непредсказуемым!
               // getName() вызовет Base::getName, но если Derived переопределяет...
               // это может привести к краху
    }
}

Риск 2: Чистые виртуальные функции в деструкторе

Это даже скомпилируется, но вызовет pure virtual function call:

class Base {
public:
    virtual void mustImplement() = 0;
    
    virtual ~Base() {
        mustImplement();  // ⚠️ Pure virtual call!
    }
};

class Derived : public Base {
public:
    void mustImplement() override {
        std::cout << "Derived implementation\n";
    }
    
    ~Derived() {}
};

int main() {
    {
        Derived d;
    }  // Runtime error: pure virtual method called!
    return 0;
}

Риск 3: Бесконечная рекурсия

class Base {
public:
    virtual void cleanup() {
        std::cout << "Base cleanup\n";
    }
    
    virtual ~Base() {
        cleanup();
    }
};

class Derived : public Base {
public:
    void cleanup() override {
        Base::cleanup();  // Явный вызов базового
        std::cout << "Derived cleanup\n";
    }
    
    ~Derived() {
        cleanup();  // Рекурсия!
    }
};

int main() {
    {
        Derived d;
    }  // Stack overflow!
}

Правильные подходы

Способ 1: Non-virtual interface (NVI)

Используй non-virtual wrapper для внутренних вызовов:

class Base {
public:
    virtual ~Base() = default;
    
protected:
    void performCleanup() {  // Non-virtual!
        doCleanup();
    }
    
    virtual void doCleanup() {
        std::cout << "Base::doCleanup\n";
    }
};

class Derived : public Base {
public:
    void doCleanup() override {
        std::cout << "Derived::doCleanup\n";
    }
    
    ~Derived() {
        performCleanup();  // Безопасно вызвать non-virtual
    }
};

Способ 2: Явный non-virtual вызов

class Base {
public:
    virtual void shutdown() { std::cout << "Base shutdown\n"; }
    
    virtual ~Base() {
        Base::shutdown();  // Явный non-virtual вызов!
    }
};

class Derived : public Base {
public:
    void shutdown() override {
        std::cout << "Derived shutdown\n";
    }
};

Способ 3: Не использовать virtual вызовы в деструкторе

class Base {
public:
    virtual ~Base() {}
    virtual void cleanup() { std::cout << "Base cleanup\n"; }
};

class Derived : public Base {
public:
    void cleanup() override {
        std::cout << "Derived cleanup\n";
    }
    
    ~Derived() {
        // Выполняем cleanup явно перед деструктором
        cleanup();  // Вызывает Derived::cleanup (ещё до деструктора)
    }
};

// Или использовать отдельную функцию
class SafeDerived : public Base {
public:
    void finalize() {  // Явная финализация
        cleanup();
    }
    
    ~SafeDerived() {
        // Cleanup уже вызван до уничтожения
    }
};

Способ 4: Шаблон RAII с отдельным cleanup

class ResourceManager {
public:
    virtual ~ResourceManager() = default;
    virtual void release() = 0;
};

class Derived : public ResourceManager {
public:
    void release() override {
        std::cout << "Derived::release\n";
    }
    
    ~Derived() {
        // НЕ вызываем release() в деструкторе
        // Вызов должен быть явным
    }
};

int main() {
    {
        auto mgr = std::make_unique<Derived>();
        // Явный вызов перед уничтожением
        mgr->release();
    }  // Деструктор без virtual вызовов
}

Диагностика и обнаружение проблем

// C++17: деструктор может быть constexpr, что помогает отловить ошибки
class Base {
public:
    virtual void doSomething() = 0;
    virtual ~Base() {
        // Статический анализ может предупредить о pure virtual call
        doSomething();  // ⚠️ Warning!
    }
};

Рекомендации

• Избегай virtual вызовов в деструкторе — это антипаттерн
• Используй NVI (Non-Virtual Interface) для внутренней логики
• Явный non-virtual вызов: Base::method() если очень нужно
• Finalize перед деструктором: отдельный метод для очистки
• Тестируй иерархии классов с множественным наследованием
• Используй инструменты статического анализа (clang-tidy, cppcheck)

Это один из самых опасных подвохов C++, и многие senior разработчики рекомендуют просто избегать virtual функций в деструкторах.