Поменять make и release так, чтобы организовать правильное уничтожение объектов и освобождение памяти

#include <iostream>
#include <memory>
struct Base
{
public:
    ~Base() { std::cout << "Base::~Base" << std::endl; }
};
 
struct First : Base
{
public:
    ~First() { std::cout << "First::~First" << std::endl; }
};
 
struct Second : Base
{
public:
    ~Second() { std::cout << "Second::~Second" << std::endl; }
};
 
std::shared_ptr<Base> make()
{
    unsigned x = 0;
    if (!(std::cin >> x))
    {
        return nullptr;
    }
    if (x & 1)
        return std::shared_ptr<Base>(new First());
    return std::shared_ptr<Base>(new Second());
}
 
 
 
 
void release(std::shared_ptr<Base> ptr)
{
    ptr.reset();
}
 
 
int main()
{
    int x = 0;
    while (x < 5)
    {
        auto ptr1 = make();
        if (ptr1 == nullptr)
        {
            break;
        }
        //...
        release(ptr1);
        x++;
    }
    system("pause");
}

#include <iostream>
 
struct Base
{
public:
    virtual void foo() {}
    ~Base() { std::cout << "Base::~Base" << std::endl; }
};
 
struct First : Base
{
public:
    void foo() override { std::cout << "First::foo" << std::endl; }
    ~First() { std::cout << "First::~First" << std::endl; }
};
 
struct Second : Base
{
public:
    void foo() override { std::cout << "Second::foo" << std::endl; }
    ~Second() { std::cout << "Second::~Second" << std::endl; }
};
 
// ugly
struct Wrapper
{
    enum class Type{ first, second };
    Wrapper(Base* base, Type type) : empty(false), type_(type), base_(base)  {}
    ~Wrapper() {
        switch(type_)
        {
            case Type::first:
                delete dynamic_cast<First*>(base_);
                break;
            case Type::second:
                delete dynamic_cast<Second*>(base_);
                break;
        }
    }
    // hack
    Wrapper(std::nullptr_t) : empty(true) {}
    bool operator==(std::nullptr_t) { return empty; }
    Base* operator->() { return base_; }
    Base& operator*() { return *base_; }
private:
    bool empty;
    Type type_;
    Base* base_;
};
bool operator==(std::nullptr_t, Wrapper& x) { return x == nullptr; }
 
Wrapper make()
{
    unsigned x = 0;
    if(!(std::cin >> x))
    {
        return nullptr;
    }
    if(x&1)
        return Wrapper{new First{}, Wrapper::Type::first};
    return Wrapper{new Second{}, Wrapper::Type::second}; 
}
 
void release(Wrapper&) {}
 
int main()
{
    while(true)
    {
        auto ptr1 = make();
        if(ptr1 == nullptr)
        {
            break;
        }
        ptr1->foo();
        release(ptr1);
    }
}