訪問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的實際訪問地址后，可以對變量進行隨意讀寫