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