Возврат значения из полиморфной функции

virtual boost::any Get () = 0;

virtual void* Get () = 0;

class CellInt: public Cell
{
   public:
          void Get ()
          {
               throw 1;
          }
};

#include <boost/any.hpp>
#include <iostream>
 
 
struct base
{
    virtual ~base(){}
    virtual boost::any workaround()const = 0;
    virtual void* govnocode()const = 0;
    virtual void total_perversion()const = 0;
};
 
 
struct der: base
{
    // можно вернуть объект любого типа
    virtual boost::any workaround()const {  return 1; }
    
    // можно вернуть указатель на объект любого типа
    virtual void* govnocode()const 
    {
          return new int(2);
    }
    
    // это для тех, кто понимает.
    // за такие приколы могут с работы уволить
    virtual void total_perversion()const 
    {
        throw 3;
    }
};
 
 
 
int main()
{
    std::cout << "Hello, world!\n";
    
    base* p = new der;
    
    const int result = boost::any_cast<int>(p->workaround());
    
    
    const int* data = static_cast<int*>(p->govnocode());
    
    
    int catched_result = 0;
    try{
       
        p->total_perversion();
    }
    catch(int& v)
    {
        catched_result = v;
    }
    
    std::cout <<"1 способ вернул результат: " << result << std::endl;
    
    std::cout <<"2 способ вернул результат: " << *data  << std::endl;
    delete data;
    
    std::cout <<"3 способ вернул результат: " << catched_result  << std::endl;
    
    delete p;
 
}

#include <iostream>
#include <typeinfo>
 
// я полиморфый void
struct PolymorphicVoid
{
    virtual ~PolymorphicVoid()
    {
    }
};
 
// а я полиморфный int, и я задаюсь вопросом всю свою жизнь: "какой идиот меня придумал?" :(
struct PolymorphicInt : PolymorphicVoid
{
private:
    int value_;
public:
    PolymorphicInt()
            : value_(0)
    {
    }
    operator int()
    {
        return value_;
    }
 
    PolymorphicInt& operator =(const int value)
    {
        value_ = value;
        return *this;
    }
};
 
struct Cell
{
    virtual PolymorphicVoid& get() = 0;
    virtual ~Cell()
    {
    }
};
 
struct CellInt: Cell
{
    PolymorphicInt int_{};
    PolymorphicInt& get() override
    {
        return int_;
    }
};
 
int main()
{
    CellInt ci;
    Cell& c = ci;
    ci.get() = 200;
 
    std::cout << typeid(c.get()).name() << std::endl;
    std::cout << typeid(ci.get()).name() << std::endl;
 
    std::cout << ci.get() << std::endl;
}

#include <boost/any.hpp>
#include <iostream>
 
 
struct base
{
    virtual ~base(){}
    virtual boost::any workaround()const = 0;
    
    template<class T> operator T()const 
    {
        return boost::any_cast<T>(this->workaround());
    }
    
};
 
 
struct der: base
{
    der(const int v = 0 ):mValue(v){}
    
    virtual boost::any workaround()const {  return mValue; }
    
    int mValue;
};
 
 
 
int main()
{
    std::cout << "Hello, world!\n";
    
    der d(100);
    base& reference = d;
    
    const int result = reference;    
    std::cout <<"результат: " << result << std::endl;
}