17.7.2 Explicit instantiation
12 The usual access checking rules do not apply to names used to specify explicit instantiations.

class A
{
public:
 
   explicit A(int value) : m_value(value) { }
 
   int GetValue() const { return m_value; }
 
private:
   int m_value;
};
 
ENABLE_PIVATE_MEMBER_ACCESS(A_value, A, int, m_value)
 
int main()
{
   A a(1);
   std::cout << "a.GetValue(): " << a.GetValue() << std::endl;
   *PrivateMemberAccessor<A_value>(a) = 42;
   std::cout << "a.GetValue(): " << a.GetValue() << std::endl;
}

R>ENABLE_PIVATE_MEMBER_ACCESS(A_value, A, int, m_value)

template<typename MemberPtrT, MemberPtrT>
struct X;

template<> struct X<decltype(&A::m_value), &A::m_value> // : Base<decltype(&A::m_value)> // нет доступа
{
    // using Q = decltype(&A::m_value);  // нет доступа
};

// Public.h
struct Public {
    static Public* create(int value);
    virtual int getValue() const=0;
    virtual ~Public() {}
};

// Public_create.cpp
#include "public.h"
#include "a_lot_of_trash_and_other_dependencies"

struct Private : Public {
    int value;
    Private(int value) : value(value) {}
    int getValue() const { return value; }
};

Public* Public::create(int value) {
    return new Private(value);
}

_NN>template<typename MemberPtrT, MemberPtrT>
_NN>struct X;

_NN>template<> struct X<decltype(&A::m_value), &A::m_value> // : Base<decltype(&A::m_value)> // нет доступа
_NN>{
_NN>    // using Q = decltype(&A::m_value);  // нет доступа
_NN>};
_NN>

template <class MemberPtr_>
struct Y
{
    using MemberPtr = MemberPtr_;
};

template <class MemberPtr>
struct X;

template <>
struct X<Y<decltype(&A::m_value)>>
{};

template <class MemberPtr>
struct X;

template <class T>
struct K {};

template <class MemberPtr_>
struct K<X<MemberPtr_>>
{
    using MemberPtr = MemberPtr_;
};

template <>
struct X<decltype(&A::m_value)>
{
    using MemberPtr = typename K<X>::MemberPtr;
};

template <>
struct X<decltype(&A::m_value)>
{
    using MemberPtr = typename K<X>::MemberPtr;
};

template <class XX>
typename XX::MemberPtr F(){}


template <class MemberPtr>
struct X;

template <class T>
struct K {};

template <class MemberPtr_>
struct K<X<MemberPtr_>>
{
    using MemberPtr = MemberPtr_;
};

template <>
struct X<decltype(&A::m_value)>
{
    using MemberPtr = typename K<X>::MemberPtr;

    friend X F(); // auto F() -> int (A::*)
};

_NN>Где код ?

#include <iostream>
#include <utility>

template<typename TagT, typename MemPtrT, MemPtrT memPtr>
struct PrivateMemerAccessEnabler
{
   using PointerToMemberType = MemPtrT;
   static constexpr const PointerToMemberType pointerToMember = memPtr;
   friend PrivateMemerAccessEnabler privateMemerAccessEnablerAux(TagT&&);
};

template <typename TagT>
using PrivateMemberAccess = decltype(privateMemerAccessEnablerAux(std::declval<TagT>()));

#define ENABLE_PRIVATE_MEMBER_ACCESS(TagT, memPtr) \
   template struct PrivateMemerAccessEnabler<struct TagT, decltype(memPtr), memPtr>;

struct A
{
public:

   int GetValue() const { return value; }

private:
   int value = -1;
};

ENABLE_PRIVATE_MEMBER_ACCESS(A_value, &A::value)

int main()
{
   const auto& memPtr = PrivateMemberAccess<A_value>::pointerToMember;

   A a;
   std::cout << a.GetValue() << std::endl;
   a.*memPtr = 42;
   std::cout << a.GetValue() << std::endl;
}

error C3861: 'privateMemerAccessEnablerAux': identifier not found
note: 'privateMemerAccessEnablerAux': function was not declared in the template definition context and can be found only via argument-dependent lookup in the instantiation context
note: see reference to alias template instantiation 'PrivateMemberAccess<A_value>' being compiled

template <>
struct X<SomeTag, decltype(&A::m_value)>
{
    using MemberPtr = typename K<X>::MemberPtr;

    SomeTag::???? ????MemberPtr
    SomeTrait<SomeTag>::???? ????MemberPtr
};

#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
}