Виртуальные методы без деструкторов

//'Parent' has virtual functions but non-virtual destructor
class Parent
{
public:
    virtual void method(){}
};
 
class FirstChild:public Parent{};
class SecondChild:public Parent{};
 
union AnyChild
{
    AnyChild(){}
 
    FirstChild firstChild;
    SecondChild secondCHild;
};
 
template<typename T>
T*create(void*mem)
{
    static_assert (std::is_trivially_destructible<T>::value);
    return new (mem) T;
}
 
int main()
{
    AnyChild*pool=new AnyChild[100];
    //создание объектов
    create<FirstChild>(pool);
    create<SecondChild>(pool+1);
    //удаление пула
    delete[] pool;
    return 0;
}

struct AnyChild
{
    std::byte m_raw[std::max(sizeof(FirstChild), sizeof(SecondChild))];
};

std::aligned_storage_t<std::max(sizeof(FirstChild), sizeof(SecondChild))>

#pragma once
#ifndef dTOOLS_PRAGMA_WARNING_USED_ 
#define dTOOLS_PRAGMA_WARNING_USED_ 1
 
#if 0
 
    // gcc
    #pragma GCC diagnostic push
    #pragma GCC diagnostic ignored "-Wold-style-cast"
    #pragma GCC diagnostic pop
 
 
    #ifdef _MSC_VER
        #pragma warning( push )
        // warning C4521: 'Arg' : multiple copy constructors specified
        #pragma warning( disable : 4521)
    #endif
 
        // code...
 
    #ifdef _MSC_VER
        #pragma warning( pop  )
    #endif
 
#endif
 
//==============================================================================
//==============================================================================
 
#if defined(__GNUC__) || defined(__MINGW__) || defined(__MINGW32__)
    #define dWRN_UNUSED_LOCAL_TYPEDEFS   "-Wunused-local-typedefs"
    #define dWRN_UNUSED_VARIABLE         "-Wunused-variable"
    #define dWRN_UNUSED_FUNCTION         "-Wunused-function"
    #define dWRN_DELETE_NON_VIRTUAL_DTRO "-Wdelete-non-virtual-dtor"
    #define dWRN_NON_VIRTUAL_DTOR        "-Wnon-virtual-dtor"
    #define dWRN_CTOR_DTOR_PRIVACY       "-Wctor-dtor-privacy"
    #define dWRN_CONVERSION_NULL         "-Wconversion-null"
    #define dWRN_OLD_STYLE_CAST          "-Wold-style-cast"
    #define dWRN_CONVERSION              "-Wconversion"
    #define dWRN_EFFC_CPP_PLUS           "-Weffc++"
#elif defined(_MSC_VER)
    #define dWRN_UNUSED_VARIABLE         4100
    #define dWRN_UNREFERENCED_VARIABLE   4101
    #define dWRN_NON_VIRTUAL_DTOR        4265
    #define dWRN_NON_VIRTUAL_DTOR        4265
    #define dWRN_UNREACHABLE_CODE        4702
    #define dWRN_FORCE_VALUE_TO_BOOL     4800
#endif
 
//==============================================================================
//==============================================================================
 
#if defined(__GNUC__) || defined(__MINGW__) || defined(__MINGW32__)
 
    #define dPRAGMA_GCC_(x) _Pragma (#x)
 
    #define dTODO(x) \
        dPRAGMA_GCC_(message ("TODO: " #x))
 
    #define dOPTIMIZE(x) \
        dPRAGMA_GCC_(message ("optimize this function: " #x ))
 
    #define dPRAGMA_DISABLE_WARNING(warning_type) \
        dPRAGMA_GCC_(GCC diagnostic ignored warning_type)
 
    #define dPRAGMA_PUSH \
        _Pragma("GCC diagnostic push")
 
    #define dPRAGMA_POP \
        _Pragma("GCC diagnostic pop")
 
#elif defined(_MSC_VER)
 
    #define dSTRINGIFY_(a) #a
    #define dSTRINGIFY(a) dSTRINGIFY_(a)
 
    #define dTODO(x) \
        __pragma(message(__FILE__"(" dSTRINGIFY(__LINE__) "): " x))
 
    #define dOPTIMIZE(x) \
        dTODO("optimize this function: " #x )
 
    #define dPRAGMA_DISABLE_WARNING(warning_type) \
        __pragma(warning(disable: warning_type))
 
    #define dPRAGMA_PUSH \
        __pragma(warning(push))
 
    #define dPRAGMA_POP \
        __pragma(warning(pop))
 
#else
    error: compiler not support
#endif
 
#define dWTF dTODO("WHAT THE FUCK ?????")
 
//==============================================================================
//==============================================================================
 
#if 0
 
    // usage:
 
    dPRAGMA_PUSH
    dPRAGMA_DISABLE_WARNING(dWRN_UNUSED_VARIABLE)
    int main()
    {
        {
            int val = 10;
        }
 
        dTODO("hello");
        dOPTIMIZE("ololo");
        dOPTIMIZE(ololo);        
        
        dWTF;
    }
    dPRAGMA_POP
 
#endif
 
//==============================================================================
//==============================================================================
 
#endif // !dTOOLS_PRAGMA_WARNING_USED_
 
dPRAGMA_PUSH
dPRAGMA_DISABLE_WARNING(dWRN_NON_VIRTUAL_DTOR)
//  warning: ‘struct sample’ 
// has virtual functions and accessible non-virtual destructor [-Wnon-virtual-dtor]
 
struct sample
{
    virtual void foo() = 0;
};
 
struct der: sample
{
    virtual void foo() 
    {
        static_assert(
            sizeof(der) == sizeof(sample),
            "invalid size"
            
        );
    }
};
dPRAGMA_POP   
 
int main()
{
}

//C++14
template<typename ... Args>
struct max_sizeof
{
    constexpr static size_t size = std::max({sizeof(Args)...});
};
 
template<typename ... Args>
constexpr size_t max_sizeof_v = max_sizeof<Args...>::size;
 
//...
max_sizeof_v<FirstType, SecondType, ThirdType>

template<typename...Args>constexpr std::size_t maxSize()
{
    return std::max(sizeof(Args)...);
}

template<typename ... Args>
constexpr size_t max_sizeof_v = std::max({sizeof(Args)...});

#include<iostream>
using namespace std;
 
struct BaseNoDestructable
{   
    BaseNoDestructable() {};
    virtual ///////
        void foo() { cout << "\nfooBase\n"; }
    //~BaseNoDestructable() = delete;//если не закомментировать - ошибка - ссылка на удалённую функцию  
};
 
struct ChildNoDestructable
    :public BaseNoDestructable////////
{   
    ChildNoDestructable() 
        :BaseNoDestructable()//////////
    {};
 
        void foo() { cout << "\nfooChild\n"; }
 
    //~ChildNoDestructable() = delete;
 
};
 
 
void TestThatMuck()
{
    const size_t pool_obj_len = 2;
    unsigned char *pool=new unsigned char[sizeof(BaseNoDestructable) * pool_obj_len];
    
    BaseNoDestructable* startObjPtr = reinterpret_cast<BaseNoDestructable*>(pool);
    new(startObjPtr)BaseNoDestructable();
    new(++startObjPtr)ChildNoDestructable();
    --startObjPtr;
    startObjPtr->foo();
    ++startObjPtr;
    startObjPtr->foo();
    delete[] pool;
 
}
 
int main()
{   
    TestThatMuck();
    return 0;
}