Question

Consider the intention behind the following illegal C++11 code:

struct Base
{
    template<typename U>
    virtual U convert() = 0;
};

template<typename T>
struct Derived : Base
{
    T t;

    template<typename U>
    virtual U convert() { return U(t); }
};

struct Any
{
    Base* b;

    template<typename U>
    operator U() { return b->convert<U>(); }
};

int main()
{
    Any a = ...;
    string s = a; // s = a->b->t if T is convertible to string
                  //    fails otherwise with compile error or runtime exception
                  //                            (either acceptable)
}

Is there a way to achieve the same or similiar effect with legal code?

(fyi the above way is illegal because templates may not be ‘virtual’)

Update:

struct Base
{
    void* p;
    type_info type;
};

template<typename T>
struct Derived : Base
{
    Derived()
    {
         p = &t; // immovable
         type = typeid(T);
    }

    T t;
};

struct Any
{
    Base* b;

    template<typename T = U, typename U>
    operator U()
    {
        if (b->type != typeid(T))
           throw exception();

        T* t = (T*) b->p;

        return U(*t);
    }
};

Answer 1

Is this what you want?

struct Base
{
  virtual void* convert(const std::type_info&) = 0;
};

template<typename T>
struct Derived : Base
{
  virtual void* convert(const std::type_info& ti)
  { return typeid(T) == ti ? &t : nullptr; }

  T t;
};

struct Any
{
  Base* b;

  template<typename U>
    operator U()
    {
      if (auto p = b->convert(typeid(U)))
        return *static_cast<U*>(p);
      throw std::exception();
    }
};

As the other answer says, it’s hard to know exactly what you want as you’ve only shown invalid code, not explained what you’re trying to achieve.

Edit oh I see now you want it to work for any convertible type, not just exact matches … then no, you can’t turn a type_info back into the type it represents, which would be needed for the derived type to test if the given type_info corresponded to a type that its stored type is convertible to. You need to know the correct type and specify it somehow, either explicitly or implicitly via deduction. If you then want to convert it to another type, you can do that separately:

Any a{ new Derived<int>() };
try {
  char c = a;  // throws
}
catch (...)
{
}
int i = a;        // OK
char c = (int)a;  // OK