#include <iostream>
#include <string>

struct C
{
    std::string b;    
};

template <typename Type, Type> struct Helper;
template <typename T, typename Type> char Finder(Helper<Type, &T::b>*);

int main()
{
    std::cout << sizeof(Finder<C, std::string C::*>(0)) << std::endl;
}

#include <iostream>
#include <string>

struct Yes{int i;};
struct No{Yes i[10];};


template< typename T,typename R > No Helper(...); 
template< typename T,typename R > Yes Helper(R (T::* t)); 

template< typename T,typename R >
struct Finder
{
enum {value=(sizeof(Helper<T,R>(&T::b)) == sizeof(Yes))};
};


struct A { int b; }; 
struct B { char b; }; 
struct C { std::string b; }; 

int main()
{

    std::cout << Finder<A,int>::value << std::endl;
    std::cout << Finder<B,int>::value << std::endl;
    std::cout << Finder<C,std::string>::value << std::endl;
}

C>Oops. There is a problem though, that the code fails to compile, when a class does not have a member with that name at all ...

#include <iostream>
#include <string>

struct Yes{int i;};
struct No{Yes i[10];};

template< typename T,typename R > No Helper(...){return No();} 
template< typename T,typename R > Yes Helper(R (T::*)){return Yes();} 
      
struct Dummy{};

template<int i>
struct X
{
    typedef Dummy type;
};
template<>
struct X<sizeof(Yes)>
{
    typedef int* type;
};

template<typename T,typename R> No Finder(...){return No();} 
template<typename T,typename R> Yes Finder(typename X<sizeof(Helper<T,R>(&T::b))>::type p){return Yes();}

struct A { int b; }; 
struct B { }; 
struct C { B b; }; 
struct D { double* b; }; 

int main()
{
    std::cout << (sizeof(Finder<A,int>(0))==sizeof(Yes))     << std::endl;
    std::cout << (sizeof(Finder<B,int>(0))==sizeof(Yes))     << std::endl;
    std::cout << (sizeof(Finder<C,B>(0))==sizeof(Yes))       << std::endl;
    std::cout << (sizeof(Finder<D,double*>(0))==sizeof(Yes)) << std::endl;
}

struct A;
struct B
{
    A* a;
};

Helper<B>::type is the same as struct A

 
namespace fl
{
struct yes_type{ char _[1]; };
struct no_type { char _[8]; };
struct _Empty;

template<typename _Cur, typename _Next>
   struct item_type0 {  typedef _Cur cur_type; typedef _Next type_next;  };

template <typename _Ty>
   yes_type _Is_regged_func(typename _Ty::_Is_registered_tag* ptr= 0);

template <typename _Ty>
   no_type _Is_regged_func(...);

template <typename _Ty>
   struct _Is_registered { static const int value = (sizeof(_Is_regged_func<_Ty>()) == sizeof(yes_type));  };

template <typename _Ty, typename _Branch = struct _New_branch >
   struct _Get_fields
{
   template <int _I=1, int _Is_regged = _Is_registered<_Ty::fields_storage<_I> > >
      struct _Iterator   
    {
            typedef item_type0<typename _Ty::fields_storage<_I>::field_type, typename _Iterator<_I+1>::result > result;       
            static const int count = _Iterator<_I+1>::count;
        };

   template <int _I >
      struct _Iterator<_I, 0>   
    {
            typedef _Empty result;       
            static const int count = _I;
        };

   typedef _Iterator<>::result result;
   static const int count = _Iterator<>::count;

};

#define serrialization(_Class) typedef _Class this_class;   template <int _I>     struct fields_storage;

#define decl_field(type, ident) type ident; \
   struct field_tag_##ident \
{  \
   typedef type result_type; typedef type this_class::*TypeField; \
   static TypeField field(){ return &this_class::ident; } \
};\
template <>\
    struct fields_storage<_Get_fields<this_class, field_tag_##ident >::count > { typedef field_tag_##ident field_type; };


}
 
struct some_class 
{
   serrialization(some_class);

   decl_field(int,m_A);
   decl_field(std::string, m_B);
};

int main()
{
    typedef fl::_Get_fields<some_class>::result fields;
    //there are we look typelist with metadata fields .. ^) thanks 
    print_type(fields);   
}

template <typename _Ty>
  struct _Accessor;

class A {  public:  int m_A;  };

//псевдокод
template<>
  struct _Accessor<A>
{
   ...
   decl_field(int, &A::m_A);
};

//typedef int X;
struct X {};

struct C
{
    X b;    
};

template <typename PtrType, PtrType PtrValue> struct Helper {};
template <typename HostType, typename DataType> char Finder(Helper<DataType HostType::*, &HostType::b>*);

int main()
{
    Helper<X C::*, &C::b> h;
    Finder(&h);
}

C>struct A;
C>struct B
C>{
C>    A* a;
C>};

C>Helper<B>::type is the same as struct A
C>

struct A8 {};
struct A9 : A8 {};
struct B8
{
    A8* a;
};
template<typename T>
struct Helper
{
    typedef T type ;
};

template<typename T>
struct IsSame
{
    template<typename T2> static bool As(T2*, T *) {return true;}
    static bool As(void *, void *) {return false;}
    template<typename T2> static bool As()
    {return  As((T2*)0,(T2*)0);}
};
template<typename T1, typename T2> 
bool AreSame()
{
    return IsSame<T1>::As<T2>() && IsSame<T2>::As<T1>();
}

int main()
{
    bool testik = AreSame<A9,Helper<A8>::type>();
    bool testik0 = AreSame<A8,Helper<A8>::type>();
    bool testik1 = IsSame<A9>::As<Helper<A8>::type>();
    bool testik2 = IsSame<Helper<A8>::type>::As<A9>();
        cout << testik << endl << testik0 << endl << testik1 << endl << testik2 << endl;
        return 0;
}

template<bool ok> struct IsDerrived{};
template<bool ok> struct InterDerrived{};
template<typename T> struct Derrived
{
    template<typename T2> 
    static IsDerrived<true> From(T2*, T *) {return IsDerrived<true>();}
    static IsDerrived<false> From(void *, void *) {return IsDerrived<false>();}
};
template<bool derrived, bool base>
InterDerrived<derrived && base> TestInterDerrived(IsDerrived<derrived>, IsDerrived<base>) {return InterDerrived<derrived && base>();}
#define AreInterDerrived(T1, T2) TestInterDerrived(Derrived<T1>::From((T2*)0,(T2*)0), Derrived<T2>::From((T1*)0,(T1*)0))

// example functions 
template<typename T1, typename T2> 
void func(T1 p1, T2 p2, void * extra, InterDerrived<true>)
{
}
template<typename T1, typename T2> 
void func(T1 p1, T2 p2, void * extra, InterDerrived<false>)
{
}
template<typename T1, typename T2> 
void func(T1 p1, T2 p2, void * extra)
{
func(p1, p2, extra, AreInterDerrived(T1,T2));
}

// use 
struct C { typedef int T; T v;};
struct A { struct A1 { typedef int T; }; A1::T v; };
template<typename T> 
struct B { typedef T TT; TT v;};

void Some(void * extData)
{
A a = A();
B<char> b = B<char>();
C c = C();
func(a.v, c.v, extData);
func(b.v, c.v, extData);
func(a.v, b.v, extData);
}

#include <iostream>
#include <string>

struct Yes{int i;};
struct No{Yes i[10];};


template< typename T,typename R > No Helper(...); 
template< typename T,typename R > Yes Helper(R (T::*)); 
template< typename T,typename R > Yes Helper(R); 

template< typename T,typename R >
struct Finder
{
    enum {value=(sizeof(Helper<T,R>(&T::b)) == sizeof(Yes))};
};


struct A { int b; }; 
struct B { char b; }; 
struct C { std::string b; }; 
struct D { int b(int) const; };
struct E { int (*b)(int); };

int main()
{
    std::cout << Finder<A, int>::value << std::endl;
    std::cout << Finder<B, char>::value << std::endl;
    std::cout << Finder<C, std::string>::value << std::endl;
    std::cout << Finder<D, int (D::*)(int) const>::value << std::endl;
    std::cout << Finder<E, int (*)(int)>::value << std::endl;

    std::cout << Finder<A, int (*)()>::value << std::endl;
    std::cout << Finder<B, int>::value << std::endl;
    std::cout << Finder<C, B>::value << std::endl;
    std::cout << Finder<D, int (D::*)(int)>::value << std::endl;
    std::cout << Finder<E, int (E::*)(int)>::value << std::endl;
}

C>Oops. There is a problem though, that the code fails to compile, when a class does not have a member with that name at all ...

#include <iostream>

template<class T,class R, R (T::* t)()=&T::member>
class member_bind
{
public:
    typedef T type;
};

template<class T1,class R, class T2>
class has_member
{
public:
    static const bool value = false;
};

template<class T,class R>
class has_member<T,R,typename member_bind<T,R>::type>
{                                           
public:
    static const bool value = true;
};

struct X{};
class A
{
public:
    X member();
};
class B {};
class C
{
public:
    int member();
};

int main(int argc, char* argv[])
{
    std::cout << "A has member? " << (has_member<A,X,A>::value ? "yes" : "no") << std::endl; 
    std::cout << "B has member? " << (has_member<B,X,B>::value ? "yes" : "no") << std::endl;
    std::cout << "C has member? " << (has_member<C,int,C>::value ? "yes" : "no") << std::endl;
    return 0;
}