访问c++类的私有成员

访问c++类的私有成员

1 目标

　　近期需要对代码进行单测覆盖，期望不改动代码仓库的情况下，单测有足够多的灵活度，直接根据历史覆盖行数，设计出全覆盖的单测。因此，访问类的私有成员变量和函数必不可少。然后，c++类本身设计为对外部访问封闭（friend class or function也是要改动代码，放弃），需要调研一下访问私有的一下trait

2 方案1

#define private public
#define protected public

　　这两行代码，在编译预处理阶段，将private和protected关键字视为marco，替换为public。由于杀伤力大，仅能定义在cpp中，且依附在需要打开的h之前

3 方案2

　　c++标准仅在一种情况下支持，在类的外部访问私有成员变量（注意是类，而非类实例），那就是显示模板实例（explicit template instantiations）。

　　参考代码：二者原理差不多

　　https://github.com/martong/access_private

　　https://gist.github.com/dabrahams/1528856

　　下面是一些用法和分析：

#include "AccessPrivate2.h"

class A {
public:
    A() {}
    int GetA() const {return ia;}
protected:
    int ib{0};
private:
    int ia {0};
};

ACCESS_PRIVATE_FIELD(A, int, ia);

int main() {
    A a;
    auto& ia = access_private::ia(a);
    ia = 3;
    return 0;
}

　　对代码进行预编译展开后，核心代码片段为：

# 8 "./AccessPrivate2.h" 2
# 21 "./AccessPrivate2.h"
namespace {
    namespace private_access_detail {
        template <typename PtrType, PtrType PtrValue, typename TagType>
        struct private_access {
            friend PtrType get(TagType) { return PtrValue; }
        };
    }
}
# 4 "main.cpp" 2


class A {
public:
    A() {}
    int GetA() const {return ia;}
protected:
    int ib{0};
private:
    int ia {0};
};

namespace {
    namespace private_access_detail {
        struct PrivateAccessTag0 {};
        template struct private_access<__decltype(&A::ia), &A::ia, PrivateAccessTag0>;
        using Alias_PrivateAccessTag0 = int;
        using PtrType_PrivateAccessTag0 = Alias_PrivateAccessTag0 A::*;
        PtrType_PrivateAccessTag0 get(PrivateAccessTag0);
    }
}

namespace {
    namespace access_private {
        int &ia(A &&t) { return t.*get(private_access_detail::PrivateAccessTag0{}); }
        int &ia(A &t) { return t.*get(private_access_detail::PrivateAccessTag0{}); }
        using XPrivateAccessTag0 = int;
        using YPrivateAccessTag0 = const XPrivateAccessTag0;
        YPrivateAccessTag0 & ia(const A &t) {
            return t.*get(private_access_detail::PrivateAccessTag0{});
        }
    }
};

int main() {
    A a;
    auto& ia = access_private::ia(a);
    ia = 3;
    return 0;
}

　　再对名空间化简，得到最简可编译运行代码

//#include "Test.h"
//#include "AccessPrivate2.h"

class A {
public:
    A() {}
    int GetA() const {return ia;}
protected:
    int ib{0};
private:
    int ia {0};
};

namespace access_private {
    // step1: global template define。
    template <typename PtrType, PtrType PtrValue>
    struct private_access {
        // friend function means it is not a part of this struct, but it can use template params, amazing
        friend PtrType get() { return PtrValue; }
    };

    // step2: explicit template instantiations : define by class name and member name
    template struct private_access<__decltype(&A::ia), &A::ia>;
    int A::* get();

    // step3: define function instance
    int &ia(A &&t) { return t.* get(); }
    int &ia(A &t) { return t.* get(); }
    const int & ia(const A &t) {
        return t.* get();
    }
}
//ACCESS_PRIVATE_FIELD(A, int, ia);

int main() {
    A a;
    auto& ia = access_private::ia(a);
    ia = 3;
    return 0;
}

　　可以看出来，替换分成3段，

　　第一段：全局的模版声明。这里面有个trait，在template struct里面仅定义了一个friend function，意味着这个函数非struct的一部分，但是可以享受到struct的模板参数，这个设计比较巧妙！

　　第二段：显示模板实例，c++里仅能访问类私有变量的地方。注意是class type的私有变量引用（偏移地址）

　　第三段：访问函数实现。参数传递class instantiation，get返回的class type的私有变量引用（偏移地址），映射到以class instantiation起始的地址上，获取实例变量的实际访问地址

　　拿到class instantiation的实际访问地址后，可以对变量进行随意读写