编程语言
首页 > 编程语言> > 访问c++类的私有成员

访问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

  下面是一些用法和分析:

 1 #include "AccessPrivate2.h"
 2 
 3 class A {
 4 public:
 5     A() {}
 6     int GetA() const {return ia;}
 7 protected:
 8     int ib{0};
 9 private:
10     int ia {0};
11 };
12 
13 ACCESS_PRIVATE_FIELD(A, int, ia);
14 
15 int main() {
16     A a;
17     auto& ia = access_private::ia(a);
18     ia = 3;
19     return 0;
20 }

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

 1 # 8 "./AccessPrivate2.h" 2
 2 # 21 "./AccessPrivate2.h"
 3 namespace {
 4     namespace private_access_detail {
 5         template <typename PtrType, PtrType PtrValue, typename TagType>
 6         struct private_access {
 7             friend PtrType get(TagType) { return PtrValue; }
 8         };
 9     }
10 }
11 # 4 "main.cpp" 2
12 
13 
14 class A {
15 public:
16     A() {}
17     int GetA() const {return ia;}
18 protected:
19     int ib{0};
20 private:
21     int ia {0};
22 };
23 
24 namespace {
25     namespace private_access_detail {
26         struct PrivateAccessTag0 {};
27         template struct private_access<__decltype(&A::ia), &A::ia, PrivateAccessTag0>;
28         using Alias_PrivateAccessTag0 = int;
29         using PtrType_PrivateAccessTag0 = Alias_PrivateAccessTag0 A::*;
30         PtrType_PrivateAccessTag0 get(PrivateAccessTag0);
31     }
32 }
33 
34 namespace {
35     namespace access_private {
36         int &ia(A &&t) { return t.*get(private_access_detail::PrivateAccessTag0{}); }
37         int &ia(A &t) { return t.*get(private_access_detail::PrivateAccessTag0{}); }
38         using XPrivateAccessTag0 = int;
39         using YPrivateAccessTag0 = const XPrivateAccessTag0;
40         YPrivateAccessTag0 & ia(const A &t) {
41             return t.*get(private_access_detail::PrivateAccessTag0{});
42         }
43     }
44 };
45 
46 int main() {
47     A a;
48     auto& ia = access_private::ia(a);
49     ia = 3;
50     return 0;
51 }

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

 1 //#include "Test.h"
 2 //#include "AccessPrivate2.h"
 3 
 4 class A {
 5 public:
 6     A() {}
 7     int GetA() const {return ia;}
 8 protected:
 9     int ib{0};
10 private:
11     int ia {0};
12 };
13 
14 namespace access_private {
15     // step1: global template define。
16     template <typename PtrType, PtrType PtrValue>
17     struct private_access {
18         // friend function means it is not a part of this struct, but it can use template params, amazing
19         friend PtrType get() { return PtrValue; }
20     };
21 
22     // step2: explicit template instantiations : define by class name and member name
23     template struct private_access<__decltype(&A::ia), &A::ia>;
24     int A::* get();
25 
26     // step3: define function instance
27     int &ia(A &&t) { return t.* get(); }
28     int &ia(A &t) { return t.* get(); }
29     const int & ia(const A &t) {
30         return t.* get();
31     }
32 }
33 //ACCESS_PRIVATE_FIELD(A, int, ia);
34 
35 int main() {
36     A a;
37     auto& ia = access_private::ia(a);
38     ia = 3;
39     return 0;
40 }

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

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

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

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

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

 

标签:return,get,私有,private,access,访问,int,c++,ia
来源: https://www.cnblogs.com/hgwang/p/15567133.html