class Handle : public IHandle_<Handle>{
    public:
        Handle(std::unique_ptr<Derived> aDerived)
            : derived(std::move(aDerived)),
              base(*aDerived) {};

        std::unique_ptr<Derived> derived;
        Base& base;
};

class Handle : public IHandle_<Handle>{
    private:
        std::unique_ptr<Derived1> myD1;
        std::unique_ptr<Derived2> myD2;

    public:
        Handle(std::unique_ptr<Derived1> aD1)
            : myD1(std::move(aD1)),
              base1(*aD1),
              base2(*aD1){};
        Handle(std::unique_ptr<Derived2> aD2)
            : myD2(std::move(aD2)),
              base1(*aD2),
              base2(*aD2){};

        Base1& base1;
        Base2& base2;

};

#include <memory>
#include <iostream>

class Base{
    public:
        Base(int ax) : x(ax){};
        virtual ~Base() = 0;
        virtual void setVal(float a) = 0;
        virtual float getVal() = 0 ;

        int x;
};

Base::~Base(){}

class Derived : public Base{
    public:
        Derived(int ax, int az)
            : Base(ax), z(az){};

        int z;
};

class Concrete : public Derived{
    public:
        Concrete(int ax, int aw, int av)
            : Derived(ax, aw),
              v(av){};
        void setVal(float a) override{
            myVal = a;
        }
        float getVal() override{
            return myVal;
        }
        float myVal;
        int v;
};

class IHandle{
    public:
        virtual ~IHandle() = 0;
};

IHandle::~IHandle(){}

template <class T>
class IHandle_ : public IHandle{
    public:
        virtual ~IHandle_() = 0;
};

template <class T>
IHandle_<T>::~IHandle_(){};

class Handle : public IHandle_<Handle>{
    public:
        Handle(std::unique_ptr<Derived> aDerived)
            : derived(std::move(aDerived)),
              base(*aDerived) {};

        std::unique_ptr<Derived> derived;
        Base& base;
};


int main(){
    std::unique_ptr<Derived> ptr(new Concrete(1, 2, 3));
    std::unique_ptr<IHandle> aHandle(new Handle(std::move(ptr)));
    Handle& handle = static_cast<Handle&>(*aHandle);
    handle.base.setVal(10.0);
    std::cout << "a = " << handle.base.getVal() << std::endl;
    return 0;
}