C
Grob skizziert könnte das ganze ungefähr so aussehen
class Base
{
public:
int a;
};
class Derived : public Base
{
public:
int b;
};
class Wrapper
{
public:
Derived derived;
};
template <typename B, typename W>
struct poly_memptr
{
friend B& operator->*(W* p, const poly_memptr<B, W>& memptr) { return memptr.apply(p); }
virtual B& apply(W*) const = 0;
};
template <typename B, typename W>
B& poly_memptr<B, W>::apply(W*) const {}
template <typename B, typename W, typename T>
struct poly_memptr_impl : poly_memptr<B, W>
{
poly_memptr_impl(T W::* p) : memptr_(p) {}
virtual T& apply(W* p) const override { return p->*memptr_; }
T W::* memptr_;
};
template <typename B, typename W, typename T>
poly_memptr_impl<B, W, T> make_mem_ptr(T W::* p) { return poly_memptr_impl<B, W, T>( p ); };
void targetfunc( const poly_memptr<Base, Wrapper>& memptr )
{
Wrapper w;
Base& foo = &w->*memptr;
}
template< typename T, typename U >
void func( T U::*memptr )
{
targetfunc( make_mem_ptr<Base>( memptr ) );
}
int main( void )
{
Derived Wrapper::*wd = &Wrapper::derived;
func( &Wrapper::derived );
return 0;
}
