如何拿到类中私有成员变量的值?
如何拿到类中私有成员变量的值?
private 限制的是编译期访问
private 是编译期访问控制,不是内存隔离机制。
看代码:
class A {
private:
int x = 100;
public:
int getX() const {
return x;
}
};
int main() {
A a;
// std::cout << a.x; // 编译错误
std::cout << a.getX(); // 正常输出 100
}
为什么 a.x 不能访问?
因为编译器在编译阶段会检查:
x是不是A的成员?x的访问权限是什么?- 当前代码有没有访问权限?
发现 x 是 private,且在类外访问,编译器就会报错。
注意:此时程序还没有运行,根本没有涉及内存保护。
它最终执行的是类似这样的机器指令:
mov eax, [地址]
只要内存地址有效、访问合法,CPU 就可以读取对应的数据。
它不会问:
“这个地址对应的变量是不是 private?”
这是因为 private 属于 C++ 语言层面的访问规则,而不是硬件层面的内存访问权限。
1. 允许修改类
如果允许修改类,优先使用 Getter 或 friend。
2. include 前 #define private public
示例
A.h
class A {
private:
int value = 42;
};
main.cpp
#define private public
#include "A.h"
#undef private
#include <iostream>
int main() {
A a;
std::cout << a.value << std::endl;
}
输出:
42
但有三个坑
- 只影响宏生效期间处理的源码,不能修改已经编译的类定义。
- 可能污染头文件,例如把标准库内部的
private也替换掉,引发编译错误。 - 存在 ODR 风险:不同翻译单元看到同一个类的不同定义,可能违反单一定义规则(ODR),不保证程序行为正确。
3. 直接通过内存地址读取 private
在某些简单对象上确实可以观察到这种现象:
#include <iostream>
class A {
private:
int x = 100;
};
int main() {
A a;
int* p = reinterpret_cast<int*>(&a);
std::cout << *p << '\n';
}
在常见实现中,可能输出:
100
这里 A 是标准布局类,x 是其首个非静态数据成员,利用了标准布局对象与首成员之间的指针可互转换关系。通过该成员的实际类型 int 读取是有标准依据的,并非单纯碰巧读对。
但这不能推广为任意类都能强转读取私有成员。如果类存在虚函数、继承、复杂布局,或者读取类型不匹配,简单强转就可能得到错误结果,甚至产生未定义行为。
#include <iostream>
class A {
private:
int x = 100;
public:
virtual void foo() {}
};
int main() {
A a;
int* p = reinterpret_cast<int*>(&a);
std::cout << *p << '\n'; // 未定义行为
}
在常见 ABI 下,内存布局可能变为:
对象内存布局示意(典型 64 位实现)
%22%20viewBox%3D%220%200%20340%20208%22%20width%3D%22100%25%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Crect%20x%3D%2270%22%20y%3D%2212%22%20width%3D%22220%22%20height%3D%2266%22%20rx%3D%228%22%20fill%3D%22%23fee2e2%22%20stroke%3D%22%23ef4444%22%2F%3E%3Ctext%20x%3D%22180%22%20y%3D%2238%22%20font-size%3D%2214%22%20text-anchor%3D%22middle%22%20font-weight%3D%22bold%22%20fill%3D%22%23991b1b%22%3Evptr%EF%BC%88%E8%99%9A%E8%A1%A8%E6%8C%87%E9%92%88%EF%BC%89%3C%2Ftext%3E%3Ctext%20x%3D%22180%22%20y%3D%2260%22%20font-size%3D%2212%22%20text-anchor%3D%22middle%22%20fill%3D%22%23991b1b%22%3E8%20bytes%3C%2Ftext%3E%3Crect%20x%3D%2270%22%20y%3D%2284%22%20width%3D%22220%22%20height%3D%2256%22%20rx%3D%228%22%20fill%3D%22%23dbeafe%22%20stroke%3D%22%233b82f6%22%2F%3E%3Ctext%20x%3D%22180%22%20y%3D%22109%22%20font-size%3D%2214%22%20text-anchor%3D%22middle%22%20font-weight%3D%22bold%22%20fill%3D%22%231e40af%22%3Eprivate%20int%20x%20%3D%20100%3C%2Ftext%3E%3Ctext%20x%3D%22180%22%20y%3D%22127%22%20font-size%3D%2212%22%20text-anchor%3D%22middle%22%20fill%3D%22%231e40af%22%3E4%20bytes%3C%2Ftext%3E%3Crect%20x%3D%2270%22%20y%3D%22146%22%20width%3D%22220%22%20height%3D%2238%22%20rx%3D%228%22%20fill%3D%22%23e2e8f0%22%20stroke%3D%22%2394a3b8%22%2F%3E%3Ctext%20x%3D%22180%22%20y%3D%22170%22%20font-size%3D%2212%22%20text-anchor%3D%22middle%22%20fill%3D%22%23334155%22%3EPadding%EF%BC%88%E5%A1%AB%E5%85%85%E5%AD%97%E8%8A%82%EF%BC%89%3C%2Ftext%3E%3Ctext%20x%3D%2257%22%20y%3D%2248%22%20font-size%3D%2212%22%20text-anchor%3D%22end%22%20fill%3D%22currentColor%22%3E%2B0%3C%2Ftext%3E%3Ctext%20x%3D%2257%22%20y%3D%22116%22%20font-size%3D%2212%22%20text-anchor%3D%22end%22%20fill%3D%22currentColor%22%3E%2B8%3C%2Ftext%3E%3Ctext%20x%3D%2257%22%20y%3D%22170%22%20font-size%3D%2212%22%20text-anchor%3D%22end%22%20fill%3D%22currentColor%22%3E%2B12%3C%2Ftext%3E%3Cpath%20d%3D%22M15%2044%20L61%2044%22%20stroke%3D%22%23ef4444%22%20stroke-width%3D%222%22%2F%3E%3Ctext%20x%3D%2215%22%20y%3D%2230%22%20font-size%3D%2211%22%20fill%3D%22%23ef4444%22%3Ep%3C%2Ftext%3E%3Ctext%20x%3D%22180%22%20y%3D%22201%22%20font-size%3D%2211%22%20text-anchor%3D%22middle%22%20fill%3D%22currentColor%22%3Ep%20%E6%8C%87%E5%90%91%E8%B5%B7%E5%A7%8B%E4%BD%8D%E7%BD%AE%EF%BC%8C%E8%80%8C%E4%B8%8D%E6%98%AF%20x%3C%2Ftext%3E%3C%2Fsvg%3E)虚表指针的位置并非由 C++ 标准统一规定,上图只是常见实现。
这时:
int* p = reinterpret_cast<int*>(&a);
p 指向的是对象的起始位置,不能假定那里有一个 int 对象。对 *p 求值可能违反类型访问规则,产生未定义行为。
即使你通过调试器知道 x 位于偏移 8 字节处,也不代表:
auto p = reinterpret_cast<int*>(
reinterpret_cast<char*>(&a) + 8
);
就成了通用、安全的方法。
原因是偏移量依赖于编译器、ABI、编译选项和具体类定义,而且还必须满足对象生命周期、对齐以及类型访问要求。
知道内存地址不等于拥有标准保证的合法访问方式。
reinterpret_cast不一定生成任何机器指令,也不会自动调整指针使其指向你希望访问的成员。它主要是在告诉编译器以另一种类型解释某个地址,至于后续解引用是否合法,仍然受到 C++ 对象模型规则的约束。
4. 模板显式实例化获取类的 private 成员指针
C++ 中有一种非常经典的模板技巧:利用模板显式实例化(Explicit Template Instantiation)获取类的 private 成员指针,从而在不修改原类定义、不使用 reinterpret_cast 的情况下读取私有成员。
这个技巧经常被称为 Rob 技巧(Rob technique),涉及 C++ 的四个知识点:
- 非类型模板参数(Non-type Template Parameter)
- 模板显式实例化(Explicit Instantiation)
- 友元函数注入(Friend Injection)
- 成员指针(Pointer-to-Member)
它最巧妙的地方是:并没有直接把 private 变成 public,而是利用显式实例化的特殊访问检查规则拿到私有成员的指针,再通过这个指针访问对象。
先看完整代码
#include <iostream>
class A {
private:
int value = 42;
};
// 1. 定义模板
template<typename Tag, typename Tag::type M>
struct Rob {
friend typename Tag::type get(Tag) {
return M;
}
};
// 2. 定义标签类型
struct AValue {
using type = int A::*;
friend type get(AValue);
};
// 3. 显式实例化
template struct Rob<AValue, &A::value>;
int main() {
A a;
// 4. 获取 private 成员指针
auto ptr = get(AValue{});
// 5. 通过成员指针读取
std::cout << a.*ptr << '\n';
}
输出:
42
这里最重要的两行是:
template struct Rob<AValue, &A::value>;
以及:
std::cout << a.*get(AValue{}) << '\n';
下面逐步拆解。
先理解什么是成员指针
普通指针:
int x = 10;
int* p = &x;
std::cout << *p;
p 保存一个普通对象的地址。
但 C++ 还有一种特殊指针:
class A {
public:
int value = 42;
};
int A::* ptr = &A::value;
注意它的类型:
int A::*
意思是:
指向
A类中某个int类型非静态数据成员的指针。
它不是普通的 int*,不能直接用 *ptr 解引用。
需要结合一个对象使用:
A a;
std::cout << a.*ptr; // 42
A* p = &a;
std::cout << p->*ptr; // 42
两种操作符分别是:
| 操作符 | 用途 |
|---|---|
.* |
对象 + 成员指针 |
->* |
对象指针 + 成员指针 |
成员指针本身不一定保存实际内存地址。具体实现中,它可能表示成员在对象内部的偏移量,但 C++ 标准不规定它的内部表示。
那么问题来了:
class A {
private:
int value = 42;
};
int A::* ptr = &A::value;
最后这行会编译失败,因为 value 是私有成员。
Rob 技巧要解决的,就是如何合法地获取这个成员指针。
核心技巧:为什么显式实例化可以访问 private?
先看一个最小例子。
class A {
private:
int value = 42;
};
template<int A::* P>
struct Test {};
普通使用时:
Test<&A::value> t; // 编译错误
因为 A::value 是私有成员。
但换一种写法:
template struct Test<&A::value>; // 合法
为什么?
因为这一行不是普通的模板使用,而是模板显式实例化定义。
假设我们定义了一个类模板:
template<typename T> struct Test { T value; };平时我们这样使用:
Test<int> a; Test<double> b;编译器发现需要
Test<int>和Test<double>,就会根据模板生成对应的特化。这叫作隐式实例化(Implicit Instantiation)。
但你也可以主动要求编译器实例化:
template struct Test<int>; template struct Test<double>;这就是显式实例化(Explicit Instantiation)。
注意语法区别:
// ① 定义类模板 template<typename T> struct Test { T value; }; // ② 使用类模板,定义对象 Test<int> a; // ③ 显式实例化类模板 template struct Test<int>;其中:
template struct Test<int>;并没有创建一个名叫
a的对象,而是要求编译器实例化Test<int>这个类模板特化。
C++ 标准有一条特殊规则:
在显式实例化声明等指定上下文中,通常的访问检查规则不适用。
也就是说,显式实例化的模板实参可以引用原本无法访问的 private 成员。这个例外是标准明确规定的,并不是编译器 Bug。
对比一下:
| 写法 | 是否允许 |
|---|---|
int A::* p = &A::value; |
不允许 |
Test<&A::value> t; |
不允许 |
template struct Test<&A::value>; |
允许 |
但是,仅仅完成显式实例化,还不能在 main() 中直接得到这个指针。
因此,我们还需要第二项技术:友元函数注入。
友元函数注入是怎么工作的?
先看一段不涉及 private 的代码:
struct Tag {};
template<typename T>
struct Injector {
friend int get(T) {
return 100;
}
};
// 显式实例化
template struct Injector<Tag>;
int main() {
int x = get(Tag{});
}
这里有一个很特别的现象:
get() 定义在 Injector 模板内部,却不是 Injector 的成员函数,而是一个命名空间作用域的友元函数。
它有两个重要特点:
- 是非成员函数,而不是
Injector::get()。 - 可以通过实参依赖查找(ADL)找到,但通常不能仅依靠普通名字查找找到。
友元函数注入与 ADL 示意
%22%20viewBox%3D%220%200%20340%20260%22%20width%3D%22100%25%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Crect%20x%3D%2276%22%20y%3D%228%22%20width%3D%22188%22%20height%3D%2252%22%20rx%3D%228%22%20fill%3D%22%23dbeafe%22%20stroke%3D%22%2360a5fa%22%2F%3E%3Ctext%20x%3D%22170%22%20y%3D%2228%22%20text-anchor%3D%22middle%22%20font-size%3D%2213%22%20font-weight%3D%22bold%22%20fill%3D%22%231d4ed8%22%3EInjector%26lt%3BTag%26gt%3B%3C%2Ftext%3E%3Ctext%20x%3D%22170%22%20y%3D%2246%22%20text-anchor%3D%22middle%22%20font-size%3D%2211%22%20fill%3D%22%231d4ed8%22%3E%E6%98%BE%E5%BC%8F%E5%AE%9E%E4%BE%8B%E5%8C%96%E6%A8%A1%E6%9D%BF%3C%2Ftext%3E%3Cpath%20d%3D%22M170%2060%20V86%22%20stroke%3D%22%2364748b%22%20stroke-width%3D%221.5%22%2F%3E%3Cpath%20d%3D%22M165%2080%20L170%2087%20L175%2080%22%20stroke%3D%22%2364748b%22%20fill%3D%22none%22%20stroke-width%3D%221.5%22%2F%3E%3Crect%20x%3D%2255%22%20y%3D%2288%22%20width%3D%22230%22%20height%3D%2254%22%20rx%3D%228%22%20fill%3D%22%23dcfce7%22%20stroke%3D%22%2322c55e%22%2F%3E%3Ctext%20x%3D%22170%22%20y%3D%22110%22%20text-anchor%3D%22middle%22%20font-size%3D%2213%22%20font-weight%3D%22bold%22%20fill%3D%22%23166534%22%3Efriend%20int%20get(Tag)%3C%2Ftext%3E%3Ctext%20x%3D%22170%22%20y%3D%22128%22%20text-anchor%3D%22middle%22%20font-size%3D%2211%22%20fill%3D%22%23166534%22%3E%E9%9D%9E%E6%88%90%E5%91%98%E5%8F%8B%E5%85%83%E5%87%BD%E6%95%B0%E5%AE%9A%E4%B9%89%3C%2Ftext%3E%3Cpath%20d%3D%22M170%20142%20V170%22%20stroke%3D%22%2364748b%22%20stroke-width%3D%221.5%22%2F%3E%3Cpath%20d%3D%22M165%20164%20L170%20171%20L175%20164%22%20stroke%3D%22%2364748b%22%20fill%3D%22none%22%20stroke-width%3D%221.5%22%2F%3E%3Crect%20x%3D%2255%22%20y%3D%22173%22%20width%3D%22230%22%20height%3D%2253%22%20rx%3D%228%22%20fill%3D%22%23fef3c7%22%20stroke%3D%22%23f59e0b%22%2F%3E%3Ctext%20x%3D%22170%22%20y%3D%22195%22%20text-anchor%3D%22middle%22%20font-size%3D%2213%22%20font-weight%3D%22bold%22%20fill%3D%22%2392400e%22%3Eget(Tag)%3C%2Ftext%3E%3Ctext%20x%3D%22170%22%20y%3D%22214%22%20text-anchor%3D%22middle%22%20font-size%3D%2211%22%20fill%3D%22%2392400e%22%3EADL%20%E6%89%BE%E5%88%B0%E5%AF%B9%E5%BA%94%E7%9A%84%E5%8F%8B%E5%85%83%E5%87%BD%E6%95%B0%3C%2Ftext%3E%3Ctext%20x%3D%22170%22%20y%3D%22250%22%20text-anchor%3D%22middle%22%20font-size%3D%2211%22%20fill%3D%22currentColor%22%3E%E5%AE%9E%E4%BE%8B%E5%8C%96%20%E2%86%92%20%E5%8F%8B%E5%85%83%E5%AE%9A%E4%B9%89%20%E2%86%92%20ADL%20%E8%B0%83%E7%94%A8%3C%2Ftext%3E%3C%2Fsvg%3E)
现在把 return 100; 换成 return M;,就可以让函数返回模板参数保存的成员指针。
逐行拆解 Rob 模板
回到完整代码中最难理解的部分:
template<typename Tag, typename Tag::type M>
struct Rob {
friend typename Tag::type get(Tag) {
return M;
}
};
第一步:Tag 是类型参数
typename Tag
表示传入一个类型,例如:
struct AValue {
using type = int A::*;
friend type get(AValue);
};
其中:
AValue::type
就是:
int A::*
M 是非类型模板参数
typename Tag::type M
相当于:
int A::* M
M 用于保存指向 A 的 int 成员的指针。
显式实例化传入私有成员
template struct Rob<AValue, &A::value>;
此时模板参数对应关系是:
Tag = AValue
M = &A::value
概念上,可以把实例化后的代码理解成:
struct Rob_AValue {
friend int A::* get(AValue) {
return &A::value;
}
};
这是帮助理解的展开示意,并不是编译器实际生成的源码。
关键在于:私有成员指针已经作为模板实参传递给了 M。
调用 get 取得成员指针
auto ptr = get(AValue{});
编译器通过 ADL 查找到对应的友元函数,得到:
int A::* ptr;
此时已经不需要在 main() 中直接写 &A::value。
读取私有成员
A a;
std::cout << a.*ptr;
为什么能访问?
因为:
a.*ptr
并没有通过名字 A::value 访问成员。
C++ 的访问控制主要针对成员名称的使用。成员指针一旦合法获得,就可以通过 .* 或 ->* 对适当类型的对象进行访问。
整个过程串起来
%22%20viewBox%3D%220%200%20340%20390%22%20width%3D%22100%25%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Crect%20x%3D%2240%22%20y%3D%228%22%20width%3D%22260%22%20height%3D%2253%22%20rx%3D%229%22%20fill%3D%22%23dbeafe%22%20stroke%3D%22%2360a5fa%22%2F%3E%3Ctext%20x%3D%22170%22%20y%3D%2229%22%20font-size%3D%2214%22%20font-weight%3D%22bold%22%20text-anchor%3D%22middle%22%20fill%3D%22%231e40af%22%3E%E2%91%A0%20%E7%A7%81%E6%9C%89%E6%88%90%E5%91%98%3C%2Ftext%3E%3Ctext%20x%3D%22170%22%20y%3D%2249%22%20font-size%3D%2212%22%20text-anchor%3D%22middle%22%20fill%3D%22%231e40af%22%20font-family%3D%22monospace%22%3EA%3A%3Avalue%20%3D%2042%3C%2Ftext%3E%3Cpath%20d%3D%22M170%2061%20v23%20m-5%20-6%205%206%205%20-6%22%20fill%3D%22none%22%20stroke%3D%22%2364748b%22%20stroke-width%3D%221.5%22%2F%3E%3Crect%20x%3D%2240%22%20y%3D%2285%22%20width%3D%22260%22%20height%3D%2253%22%20rx%3D%229%22%20fill%3D%22%23fef3c7%22%20stroke%3D%22%23f59e0b%22%2F%3E%3Ctext%20x%3D%22170%22%20y%3D%22106%22%20font-size%3D%2214%22%20font-weight%3D%22bold%22%20text-anchor%3D%22middle%22%20fill%3D%22%2392400e%22%3E%E2%91%A1%20%E6%98%BE%E5%BC%8F%E5%AE%9E%E4%BE%8B%E5%8C%96%3C%2Ftext%3E%3Ctext%20x%3D%22170%22%20y%3D%22126%22%20font-size%3D%2212%22%20text-anchor%3D%22middle%22%20fill%3D%22%2392400e%22%20font-family%3D%22monospace%22%3ERob%26lt%3BAValue%2C%20%26amp%3BA%3A%3Avalue%26gt%3B%3C%2Ftext%3E%3Cpath%20d%3D%22M170%20138%20v23%20m-5%20-6%205%206%205%20-6%22%20fill%3D%22none%22%20stroke%3D%22%2364748b%22%20stroke-width%3D%221.5%22%2F%3E%3Crect%20x%3D%2240%22%20y%3D%22162%22%20width%3D%22260%22%20height%3D%2253%22%20rx%3D%229%22%20fill%3D%22%23e0e7ff%22%20stroke%3D%22%23818cf8%22%2F%3E%3Ctext%20x%3D%22170%22%20y%3D%22183%22%20font-size%3D%2214%22%20font-weight%3D%22bold%22%20text-anchor%3D%22middle%22%20fill%3D%22%233730a3%22%3E%E2%91%A2%20%E5%8F%8B%E5%85%83%E5%87%BD%E6%95%B0%3C%2Ftext%3E%3Ctext%20x%3D%22170%22%20y%3D%22203%22%20font-size%3D%2212%22%20text-anchor%3D%22middle%22%20fill%3D%22%233730a3%22%20font-family%3D%22monospace%22%3Eget(AValue)%20%E8%BF%94%E5%9B%9E%20M%3C%2Ftext%3E%3Cpath%20d%3D%22M170%20215%20v23%20m-5%20-6%205%206%205%20-6%22%20fill%3D%22none%22%20stroke%3D%22%2364748b%22%20stroke-width%3D%221.5%22%2F%3E%3Crect%20x%3D%2240%22%20y%3D%22239%22%20width%3D%22260%22%20height%3D%2253%22%20rx%3D%229%22%20fill%3D%22%23dcfce7%22%20stroke%3D%22%234ade80%22%2F%3E%3Ctext%20x%3D%22170%22%20y%3D%22260%22%20font-size%3D%2214%22%20font-weight%3D%22bold%22%20text-anchor%3D%22middle%22%20fill%3D%22%23166534%22%3E%E2%91%A3%20ADL%20%E6%9F%A5%E6%89%BE%3C%2Ftext%3E%3Ctext%20x%3D%22170%22%20y%3D%22280%22%20font-size%3D%2212%22%20text-anchor%3D%22middle%22%20fill%3D%22%23166534%22%20font-family%3D%22monospace%22%3Eauto%20ptr%20%3D%20get(AValue%7B%7D)%3C%2Ftext%3E%3Cpath%20d%3D%22M170%20292%20v23%20m-5%20-6%205%206%205%20-6%22%20fill%3D%22none%22%20stroke%3D%22%2364748b%22%20stroke-width%3D%221.5%22%2F%3E%3Crect%20x%3D%2240%22%20y%3D%22316%22%20width%3D%22260%22%20height%3D%2253%22%20rx%3D%229%22%20fill%3D%22%23d1fae5%22%20stroke%3D%22%2310b981%22%2F%3E%3Ctext%20x%3D%22170%22%20y%3D%22337%22%20font-size%3D%2214%22%20font-weight%3D%22bold%22%20text-anchor%3D%22middle%22%20fill%3D%22%23065f46%22%3E%E2%91%A4%20%E6%88%90%E5%91%98%E6%8C%87%E9%92%88%E8%AE%BF%E9%97%AE%3C%2Ftext%3E%3Ctext%20x%3D%22170%22%20y%3D%22357%22%20font-size%3D%2212%22%20text-anchor%3D%22middle%22%20fill%3D%22%23065f46%22%20font-family%3D%22monospace%22%3Ea.*ptr%20%20%E2%86%92%20%2042%3C%2Ftext%3E%3C%2Fsvg%3E)
这种方法有什么风险?
相比 reinterpret_cast 猜测对象布局,这种方法不需要假定 private 成员的内存偏移,也不需要把对象地址强制转换成不相干的指针类型。
但不代表它适合生产环境。
主要风险包括:
- 破坏封装:可以绕过类设计者规定的访问接口。
- 依赖内部实现:成员改名或改变类型后,代码可能无法编译。
- 维护成本高:涉及 ADL、显式实例化及友元查找,普通开发者很难快速理解。
- 友元查找细节复杂:重复实例化、相同签名的友元定义等情况需要特别注意,不能简单地把这套技巧推广到所有场景。
另外,Rob 技巧不是任意内存读取。它仍然要求使用正确类型的成员指针,并对有效对象进行访问。

浙公网安备 33010602011771号