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

//'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;
}

#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;
}

BaseNoDestructable *nullPtrCall = nullptr;
    nullPtrCall->foo();

#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;
}

class Parent
{
public:
    virtual void method(){}
};
 
int main()
{
    auto value=new Parent;
    delete value;//deleting object of polymorphic class type ‘Parent’ which has non-virtual destructor might cause undefined behavior
    return 0;
}