#include <array>
#include <stack>

struct Blargh {
    int a;
    int b;
    int c;
};

template <typename T>
struct BizBizangType;

template <typename T>
using biz_bizang_t = struct BizBizangType;

template <template <typename> class Derived, typename T>
struct BizBizang
{
    virtual ~BizBizang() {}

    BizBizang(BizBizang&& other) noexcept
    {
        data_ptr_->~T();
        data_ptr_ = other.data_ptr_;
        other.data_ptr_->~T();
        other.data_ptr_ = nullptr;
    }

    BizBizang& operator=(BizBizang other)
    {
        swap(other);
        return *this;
    }

    operator T*() const
    {
        return data_ptr_;
    }

    operator T*()
    {
        return data_ptr_;
    }

    T& operator->() const
    {
        return data_ptr_;
    }

    T& operator->()
    {
        return data_ptr_;
    }

protected:
    BizBizang() = default;

    BizBizang(const T& pod) :
    data_ptr_(new (pod_buffer()) T(pod))
    {}

private:
     void swap(BizBizang& other)
    {
        std::swap(data_ptr_, other.data_ptr_);
    }

    static char* pod_buffer()
    {
        static auto buf = new char[sizeof(T)];
        return buf;
    }

    T* data_ptr_ = nullptr;
};

template <typename T>
class BizBizangMaker
{
public:
    BizBizangMaker() = delete;

    static biz_bizang_t<T>* MakeBizang(const T& pod,
                                       std::stack<biz_bizang_t<T>*>&
                                       event_ptr_stack)
    {
        static size_t index;
        static std::array<biz_bizang_t<T>, 10> fart = init_from_f<10>();

        //fart[index] = biz_bizang_t<T>(pod);
        //return &fart[index++];
    }

private:
    //std::stack<biz_bizang_t<T>*> stack;

    template <size_t N>
    static constexpr std::array<biz_bizang_t<T>, N> init_from_f() {
    std::array<biz_bizang_t<T>, N> a;
    for (size_t i = 0; i < N; ++i)
        a[i] = BizBizangType<T>();
    return a;
    }

};

template <typename T>
struct BizBizangType : public BizBizang<BizBizangMaker, T>
{
    BizBizangType() = default;
    BizBizangType(const T& pod) : BizBizang<BizBizangMaker, T>(pod) {}
};

int main()
{
    struct Blargh bar{1, 2, 3};
    //auto shit = BizBizangMaker<Blargh>::MakeBizang(bar);
}