fork download

copy

#include <iostream>
 
struct A
{
public:
 
	int GetValue() const { return value; }
 
private:
    int q[100];
 
	int value = -1;
};
 
template<class MemberPtr, MemberPtr Mem>
struct MemberTag;
 
 
template<typename T>
struct MemberOffset
{
    static intptr_t offset;
};
 
template<typename T>
intptr_t MemberOffset<T>::offset;
 
 
template<typename T>
struct Registrator
{
    template<class PointerToMemberType, PointerToMemberType Member>
    struct RegistratorInner
    {
        using TheType = PointerToMemberType;
        static constexpr TheType TheMember = Member;
 
        struct OffsetInitializer
        {
            OffsetInitializer()
            {
                // Hack to get runtime value of pointer-to-member
                union PtrUnion
                {
                    PointerToMemberType m;
                    intptr_t i;
                };
 
 
                PtrUnion p;
                p.m = Member;
 
                MemberOffset<T>::offset = p.i;
            }
        };
 
        static OffsetInitializer offsetInitializer;
    };
};
 
 
template<typename T>
template<class PointerToMemberType, PointerToMemberType Member>
typename Registrator<T>::template RegistratorInner<PointerToMemberType, Member>::OffsetInitializer
    Registrator<T>::RegistratorInner<PointerToMemberType, Member>::offsetInitializer;
 
 
template<class T>
struct MemberExtractor {};
 
// Extractor specialization
template<class PointerToMemberType, PointerToMemberType Member>
struct MemberExtractor<MemberTag<PointerToMemberType, Member>>
{
    using TheType = PointerToMemberType;
    static constexpr TheType TheMember = Member;
};
 
// Private member specialization
template<>
struct MemberTag<decltype(&A::value), &A::value>
{
    using TheType = typename MemberExtractor<MemberTag>::TheType;
    static constexpr TheType TheMember = MemberExtractor<MemberTag>::TheMember;
 
    // Extract type
    virtual typename Registrator<A>::RegistratorInner<TheType, TheMember>::OffsetInitializer F()
    {
        return Registrator<A>::RegistratorInner<TheType, TheMember>::offsetInitializer;
    }
};
 
template<>
struct MemberTag<decltype(&A::value), &A::value>;
 
int main()
{
    std::cout << MemberOffset<A>::offset; // 400
}
 

prog.cpp:87:73: error: ‘MemberTag<int A::*, &A::value>::TheMember’ is not a valid template argument for type ‘int A::*’
     virtual typename Registrator<A>::RegistratorInner<TheType, TheMember>::OffsetInitializer F()
                                                                         ^
prog.cpp:87:73: error: it must be a pointer-to-member of the form ‘&X::Y’
prog.cpp:87:73: error: could not convert template argument ‘MemberTag<int A::*, &A::value>::TheMember’ to ‘int A::*’
prog.cpp: In member function ‘virtual int MemberTag<int A::*, &A::value>::F()’:
prog.cpp:89:67: error: ‘MemberTag<int A::*, &A::value>::TheMember’ is not a valid template argument for type ‘int A::*’
         return Registrator<A>::RegistratorInner<TheType, TheMember>::offsetInitializer;
                                                                   ^
prog.cpp:89:67: error: it must be a pointer-to-member of the form ‘&X::Y’
prog.cpp:89:67: error: could not convert template argument ‘MemberTag<int A::*, &A::value>::TheMember’ to ‘int A::*’

Standard output is empty