Реализация полиморфного контейнера

#include <iostream>
#include <string>
#include <memory>
 
 
class Figure
{
public:
   Figure() {}
   virtual int size() = 0;
};
 
class Rhombus : public Figure
{
private:
   int number;
 
public:
   Rhombus(int number) { this->number = number; }
   int size() { return this->number; }
};
 
class Triangle : public Figure
{
private:
   int number;
 
public:
   Triangle(int number) { this->number = number; }
   int size() { return this->number; }
};
 
class Octagon : public Figure
{
private:
   int number;
 
public:
   Octagon(int number) { this->number = number; }
   int size() { return this->number; }
};
 
class Oval : public Figure
{
private:
   int number;
 
public:
   Oval(int number) { this->number = number; }
   int size() { return this->number; }
};
 
void number_nodes(std::unique_ptr<Figure> temp)
{
   std::cout << "number : " <<temp->size() << std::endl;
}
 
int main() {
    std::unique_ptr<Figure> t = std::make_unique<Triangle>(3);
    std::unique_ptr<Figure> oc = std::make_unique<Octagon>(8);
    std::unique_ptr<Figure> r = std::make_unique<Rhombus>(4);
    std::unique_ptr<Figure> ov = std::make_unique<Oval>(1);
    number_nodes(std::move(t));
    number_nodes(std::move(oc));
    number_nodes(std::move(r));
    number_nodes(std::move(ov));
    return 0;
}

std::vector<std::shared_ptr<Figure>>

template<typename T>
class super_polymorphic_vector : public std::vector<std::shared_ptr<T>>
{
}

std::vector<virtual_wrapper<Figure>> v{};
v.push_back(Oval{12}); // что в принципе лучше заменить на emplace_back
v.push_back(Triangle{2});

using interface_t = std::vector<std::shared_ptr<T>>;
interface_t* p = new super_polymorphic_vector ;
delete p;

#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wnon-virtual-dtor"
 
namespace tools
{
    template<class t> struct is_polymorphic
    {
        struct der: public t
        {
            virtual ~der() = 0;
        };
        enum { value = sizeof(t) == sizeof(der) };
        static_assert(value != 0 || sizeof(t) < sizeof(der), "err");
    };
    
    
} //namespace tools
 
#include <iostream>
#include <type_traits>
 
struct A { int m; };
struct B { virtual void foo(); };
struct C : B {};
struct D { virtual ~D() = default; };
 
#define dSTD(t) std::is_polymorphic<t>::value
#define dTOOLS(t) tools::is_polymorphic<t>::value
 
 
int main()
{
    std::cout << std::boolalpha
          << dSTD(A) << " VS " << dTOOLS(A) << '\n'
          << dSTD(B) << " VS " << dTOOLS(B) << '\n'
          << dSTD(C) << " VS " << dTOOLS(C) << '\n'
          << dSTD(D) << " VS " << dTOOLS(D) << '\n';
}
 
#pragma GCC diagnostic pop

sizeof(t) == sizeof(der)

static_assert(value != 0 || sizeof(t) < sizeof(der), "err");