private メンバにアクセス（写経）

private-access.cpp

#include <iostream>

// impl ----------

template <typename T>
struct accessor {
    static typename T::type value;
};

template <typename T>
typename T::type accessor<T>::value;

template <typename T, typename T::type P>
struct deprivate {
    deprivate() { accessor<T>::value = P; }
    static deprivate instance;
};

template <typename T, typename T::type P>
deprivate<T, P> deprivate<T, P>::instance;

template <typename T, typename U> struct private_member { using type = U T::*; };

template <typename T, typename U>
auto get_private(const U &u) { return u.*accessor<T>::value; }

#define PRIVATE_TAG(CLASS, MEMBER) _private_tag$ ## CLASS ## $ ## MEMBER

#define PRIVATE_ACCESS(CLASS, MEMBER_T, MEMBER) \
    struct PRIVATE_TAG(CLASS, MEMBER) : private_member<CLASS, MEMBER_T> {}; \
    template struct deprivate<PRIVATE_TAG(CLASS, MEMBER), &CLASS::MEMBER>;

#define PRIVATE_GET(CLASS, MEMBER, INSTANCE) get_private<PRIVATE_TAG(CLASS, MEMBER)>(INSTANCE)

// usage ----------

struct foo {
public:
    foo(int value) : _value(value), _value2(456) {}
    
    int value() const { return _value; }
    
private:
    int _value;
    int _value2;
};

PRIVATE_ACCESS(foo, int, _value);
PRIVATE_ACCESS(foo, int, _value2);

int main()
{
    foo a(123);
    
    std::cout << a.value() << std::endl;
    
    std::cout << get_private<PRIVATE_TAG(foo, _value)>(a) << std::endl;
    std::cout << get_private<_private_tag$foo$_value>(a) << std::endl;
    std::cout << PRIVATE_GET(foo, _value, a) << std::endl;
    
    std::cout << PRIVATE_GET(foo, _value2, a) << std::endl;
    
    return 0;
}

参考サイト

• privateメンバに外部から非侵入的にアクセスする
• dabrahams/private_access.cpp