是的，我完全意识到我所询问的内容是非常愚蠢的，任何想在生产代码中尝试这样做的人都应该被解雇和/或开除。 我主要是想看看是否能够实现。
既然这件事已经解决了，有没有办法从类外部访问C++中的私有类成员呢？例如，是否可以使用指针偏移量来完成此操作？
（欢迎使用天真和其他非生产准备技术）
如评论所述，我提出这个问题是因为我想写一篇关于过度封装（以及它如何影响测试驱动开发）的博客文章。我想看看是否有一种方式可以说“即使在C ++中，使用私有变量也不是100％可靠的实施封装”的方法。最终，我决定更专注于如何解决问题而不是为什么这是一个问题，因此我没有像计划的那样突出显示这里提出的一些东西，但我仍然放了一个链接。
无论如何，如果有人对结果感兴趣，这是链接：测试驱动开发敌人之一：封装（我建议在认为我疯了之前先阅读它）。
class safe
{
int money;
public:
safe()
: money(1000000)
{
}
template <typename T>
void backdoor()
{
// Do some stuff.
}
};
主程序.cpp：
#include <safe.h>
#include <iostream>
class key;
template <>
void safe::backdoor<key>()
{
// My specialization.
money -= 100000;
std::cout << money << "\n";
}
int main()
{
safe s;
s.backdoor<key>();
s.backdoor<key>();
}
输出：
900000
800000
我已经添加了一个博客条目（见下文），展示了如何完成它。以下是一个关于如何在以下类中使用它的示例
struct A {
private:
int member;
};
只需声明一个结构体，其中描述它并实例化用于抢劫的实现类
// tag used to access A::member
struct A_member {
typedef int A::*type;
friend type get(A_member);
};
template struct Rob<A_member, &A::member>;
int main() {
A a;
a.*get(A_member()) = 42; // write 42 to it
std::cout << "proof: " << a.*get(A_member()) << std::endl;
}
Rob类模板的定义如下，只需定义一次，无论您计划访问多少个私有成员。
template<typename Tag, typename Tag::type M>
struct Rob {
friend typename Tag::type get(Tag) {
return M;
}
};
template struct Rob<A_member, &A::member>; 这是一个显式的模板类实例化。 &A::member 在这里起作用因为：“显式实例化定义忽略成员访问说明符：参数类型和返回类型可以是私有的”。 - bartolo-otrita.*get(A_member()) 调用非成员友元函数 get(A_member)，该函数返回 &A::member。这是因为 "friend injection"。尝试删除 get() 函数的 "无用" 参数，你应该会得到 "get was not declared in this scope"（我想看到一个简明扼要的解释这种行为）。A :: member不是int而是一个名为Foo的私有枚举类型时，是否有可能进行修改？ - M.M#define private public
#define class struct
但这是对你的问题的回答，在那里你明确邀请了一项技术，我引用你的话：“这是完全愚蠢的技术，任何想在生产代码中尝试这样做的人都应该被解雇或开除。”
另一种技术是访问私有成员数据，通过使用从对象开头开始的硬编码/手工编码偏移量构造指针。
class可以用于模板参数（与typename相同），但struct不能。 - user202729嗯，不确定这是否有效，但值得一试。创建另一个与具有私有成员相同布局的类，但将 private 更改为 public。创建一个指向此类的指针变量。使用简单的强制转换将其指向您具有私有成员的对象，并尝试调用私有函数。
预计会出现火花，可能会崩溃 ;)
class A
{
int a;
}
class B
{
public:
int b;
}
union
{
A a;
B b;
};
应该就这样了。
注：对于这种简单的类来说，它可以工作，但通常情况下不行。
《C++程序设计语言》第 C.8.3 节: "一个具有构造函数、析构函数或复制操作的类不能成为联合成员的类型......因为编译器无法知道要销毁哪个成员。"
因此，我们最好声明class B以匹配A的布局并且通过访问类的私有成员进行hack。
如果你能够获取一个类成员的指针，那么无论访问权限是什么（甚至是方法），你都可以使用这个指针。
class X;
typedef void (X::*METHOD)(int);
class X
{
private:
void test(int) {}
public:
METHOD getMethod() { return &X::test;}
};
int main()
{
X x;
METHOD m = x.getMethod();
X y;
(y.*m)(5);
}
当然，我最喜欢的小技巧就是友元模板后门。
class Z
{
public:
template<typename X>
void backDoor(X const& p);
private:
int x;
int y;
};
假设上述代码的创建者已经为正常使用定义了backDoor。但是你想访问这个对象并查看私有成员变量。即使上述类已经编译成静态库，你也可以添加自己的backDoor模板特化来访问成员。
namespace
{
// Make this inside an anonymous namespace so
// that it does not clash with any real types.
class Y{};
}
// Now do a template specialization for the method.
template<>
void Z::backDoor<Y>(Y const& p)
{
// I now have access to the private members of Z
}
int main()
{
Z z; // Your object Z
// Use the Y object to carry the payload into the method.
z.backDoor(Y());
}
test()是private的，而getMethod()（是public的）返回的值可以是任何东西。2：不，你不能从外部获取指针。 - Martin York在C++中，使用指针偏移量访问私有成员是完全可能的。假设我有以下类型定义，我想要访问它的成员。
class Bar {
SomeOtherType _m1;
int _m2;
};
SomeOtherType& GetM1(Bar* pBar) {
return*(reinterpret_cast<SomeOtherType*>(pBar));
}
现在_m2有点难。我们需要将原始指针从原始位置移动sizeof(SomeOtherType)个字节。将其强制转换为char是为了确保我在递增字节偏移量。
int& GetM2(Bar* pBar) {
char* p = reinterpret_cast<char*>(pBar);
p += sizeof(SomeOtherType);
return *(reinterpret_cast<int*>(p));
}
std::remove_reference并替换nullptr）。
#define CONCATE_(X, Y) X##Y
#define CONCATE(X, Y) CONCATE_(X, Y)
#define ALLOW_ACCESS(CLASS, MEMBER, ...) \
template<typename Only, __VA_ARGS__ CLASS::*Member> \
struct CONCATE(MEMBER, __LINE__) { friend __VA_ARGS__ CLASS::*Access(Only*) { return Member; } }; \
template<typename> struct Only_##MEMBER; \
template<> struct Only_##MEMBER<CLASS> { friend __VA_ARGS__ CLASS::*Access(Only_##MEMBER<CLASS>*); }; \
template struct CONCATE(MEMBER, __LINE__)<Only_##MEMBER<CLASS>, &CLASS::MEMBER>
#define ACCESS(OBJECT, MEMBER) \
(OBJECT).*Access((Only_##MEMBER<std::remove_reference<decltype(OBJECT)>::type>*)nullptr)
ALLOW_ACCESS(<class>, <member>, <type>);
ACCESS(<object>, <member>) = <value>; // 1
auto& ref = ACCESS(<object>, <member>); // 2
struct X {
int get_member () const { return member; };
private:
int member = 0;
};
ALLOW_ACCESS(X, member, int);
int main() {
X x;
ACCESS(x, member) = 42;
std::cout << "proof: " << x.get_member() << std::endl;
}
enum Foo 的私有成员，因为 Foo 也在私有部分中。由于 Class::Foo 是私有的，所以它不能在 ALLOW_ACCESS 宏中使用！有什么建议吗？ - M.M很酷的问题，以下是我的回答：
using namespace std;
class Test
{
private:
int accessInt;
string accessString;
public:
Test(int accessInt,string accessString)
{
Test::accessInt=accessInt;
Test::accessString=accessString;
}
};
int main(int argnum,char **args)
{
int x;
string xyz;
Test obj(1,"Shit... This works!");
x=((int *)(&obj))[0];
xyz=((string *)(&obj))[1];
cout<<x<<endl<<xyz<<endl;
return 0;
}