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

Если я вас правильно понимаю, у вас есть иерархия сущностей, производные из которых (A, B и т. д.) содержат разные типы данных.

Самым простым решением было бы удалить V из Base и добавить определенный элемент данных (без указателя) в каждый производный класс. Таким образом, вам вообще не придется иметь дело с удалением V.

Если по какой-то причине вы хотите отделить основные объекты от данных, которые они хранят (чтобы база имела к ним доступ), вы можете создать отдельную иерархию объектов данных (BaseData, AData, BData и т. д.). Вы также можете использовать интеллектуальный указатель, чтобы избежать ручного управления памятью.

Это показано ниже:

#include <memory>
#include <array>

// Hirarchy of data entities:

struct BaseData { 
    virtual ~BaseData() = default; // required for proper destruction of derived classes
};

struct AData : public BaseData {
    int m_data{ 0 };
};

struct BData : public BaseData {
    double m_data{ 0 };
};

struct CData : public BaseData {
    std::array<int, 4> m_data{ 0 };
};


// Hirarchy of main entities:

class Base {
public:
    std::unique_ptr<BaseData> m_V;
    virtual ~Base() = default; // required for proper destruction of derived classes
};

class A : public Base {
public:
    A() { m_V = std::make_unique<AData>(); }
};

class B : public Base {
public:
    B() { m_V = std::make_unique<BData>(); }
};

class C : public Base {
public:
    C() { m_V = std::make_unique<CData>(); }
};

Примечания:

1. Я использовал std::array вместо необработанного массива C.
2. Объекты данных structs предназначены только для простоты.
3. Как упоминал @Jens в комментарии, вы можете добавить конструктор для Base принятия std::unique_ptr<BaseData>, чтобы убедиться, что производные классы инициализируются m_V. m_V также можно сделать приватным, разрешив доступ к нему через метод доступа.

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

И еще одно: вы используете наследование для совместного использования реализации. Обычно это не лучший подход; используйте наследование для совместного использования интерфейсов и композицию для совместного использования реализации. Я бы предложил решить вашу проблему, создав класс хранения данных, который A, B и C могут хранить в качестве переменной-члена.

Следующие решения ориентированы на ответ через наследование, потому что вы об этом спрашивали, но вы можете адаптировать их для использования через композицию, если решите следовать моему совету выше.

Шаблоны

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

template<typename DataType>
class Base {
public:
    DataType V{};
    virtual ~Base() = default;
};
class A : public Base<int> {};

Умные указатели

Решение с использованием unique_ptr уже было дано в другом ответе. Общий указатель занимает больше памяти, но упрощает реализацию за счет стирания типа:

class Base {
public:
    std::shared_ptr<void> V;
    virtual ~Base() = default;
};
class A : public Base {
public:
    A() : V{std::make_shared<int>()} {}
};

Переменная _type

Я знаю, что у вас проблемы с памятью. Но если вы не работаете в чрезвычайно ограниченной среде или вам не нужны тысячи экземпляров этого класса (в этом случае распределение кучи в любом случае уже будет гораздо более серьезной проблемой), это не будет иметь значения.

Другую проблему, связанную с необходимостью установки _type, можно решить, просто добавив конструктор:

class Base {
public:
    void* V;
    Base(int* a) : V{a}, _type{Int} {}
    // ... constructors for other supported data types
    virtual ~Base() { switch (_type) { ... } }

private:
    enum { Int, Double, IntArray } _type;
};
class A : public Base {
public:
    A():Base{new int} {}
};

станд::вариант

Решение _type можно значительно улучшить, используя std::variant, который делает все это за вас и без выделения кучи:

class Base {
public:
    std::variant<int, double, std::array<int, 4>> V;
    virtual ~Base() = default;
};
class A : public Base {
public:
    A() :V{std::in_place_type<int>} {}
};

Я действительно думаю, что тебе стоит послушать @Wutz,

но так как я немного поигрался с этим, вот нубский, мирской подход, похожий на вашу реализацию, печатающую typeid() (которую вы не должны использовать как есть)

#include <iostream>
#include <cstring>
using std::cout;
using std::endl;

template<class T>
class Base {
public:
   char type;// explicit type, what you didn't want right?!
   T* V;
   Base(char c):type(c){};
   virtual ~Base() { 
       cout<<"Base desctruct : explicit obj type "<< type <<" _ type "<< typeid( this ).name()<< " V type is "<< typeid( V ).name()<< " *V type is "<< typeid( *V ).name() <<endl;
       if (V){/* in case user deleted it already */
        cout<<"\t _ value is "<<*V <<" ("<<V<<')'<<endl;
           delete [] V;
           delete V;
           V = 0;
           cout<<"\tDeleted V form Base"<<endl;
           }else cout<<"\tNothing to delete"<<endl;
        if (V){
           cout<<"V still exists"<<endl;
           }
    }
};

class A : public Base<char> {
public:
   A() : Base('A') { V = new char[12];strcpy(V,"AAA_AAA");}
   virtual ~A() {
   }
};
class B : public Base<double> {
public:   
    B() : Base('B') {V = new double(1.618);}
};

class C : public Base<int> {
public:   
   C(): Base('C')   {V = new int[4]{8,2,3,4};}
};

class D : public C {
public:   
   D(): C()   {type = 'D';}
      virtual ~D() {
          cout<<"Child desctruct : obj type "<< type <<endl;
        if (V){         
            delete [] V;
           delete V;
           V=0;
           cout<<"\tDeleted V from child"<<endl;
           }
   }
};

int main(){
    A *a = new A();
    delete a;
    B *b = new B();
    delete b;
    C *c = new C();
    delete c;
    A a2;
    D d;
    return 0;
}

он выводит

Base desctruct : explicit obj type A _ type P4BaseIcE V type is Pc *V type is c
         _ value is A (AAA_AAA)
        Deleted V form Base
Base desctruct : explicit obj type B _ type P4BaseIdE V type is Pd *V type is d
         _ value is 1.618 (0xe51908)
        Deleted V form Base
Base desctruct : explicit obj type C _ type P4BaseIiE V type is Pi *V type is i
         _ value is 8 (0xe519f8)
        Deleted V form Base
Child desctruct : obj type D
        Deleted V from child
Base desctruct : explicit obj type D _ type P4BaseIiE V type is Pi *V type is i
        Nothing to delete
Base desctruct : explicit obj type A _ type P4BaseIcE V type is Pc *V type is c
         _ value is A (AAA_AAA)
        Deleted V form Base