你好,我在某个资源上找到了类似的代码(自己稍微修改了一下):
#include <iostream>
using namespace std;
class PrivateClass
{
public:
PrivateClass(int a, char b)
: privateInt(a), privateChar(b) {}
int getInt() {return privateInt; }
char getChar() {return privateChar; }
private:
int privateInt;
char privateChar;
};
class Stealer
{
public:
int &stealInt(PrivateClass &clss)
{
return ((Stealer *) (&clss))->stealedInt;
}
char &stealChar(PrivateClass &clss)
{
return ((Stealer *) (&clss))->stealedChar;
}
private:
int stealedInt;
char stealedChar;
};
int main()
{
PrivateClass prVar(20, 'a');
Stealer stVar;
int &stlInt = stVar.stealInt(prVar);
char &stlChar = stVar.stealChar(prVar);
cout << "Private Class:\nInt = " << prVar.getInt() << "\nChar = " << prVar.getChar() << endl;
cout << "\nStealed:\nInt = " << stlInt << "\nChar = " << stlChar << endl;
stlInt = -65;
stlChar = 'q';
cout << "Int = " << stlInt << "\nChar = " << stlChar << endl;
cout << "\nPrivate Class:\nInt = " << prVar.getInt() << "\nChar = " << prVar.getChar() << endl;
return 0;
}
结果:
Private Class:
Int = 20
Char = a
Stealed:
Int = 20
Char = a
Int = -65
Char = q
Private Class:
Int = -65
Char = q
据我了解,Stealer 类以某种方式访问了 PrivateClass 类的私有字段,甚至通过引用,这使得“从外部”更改变量的值成为可能。las,我还没有在任何地方找到明确的答案。会是什么呢?
肮脏的骇客:)
简单做了一个结构相似的类,将一个类占用的内存区域声明为另一个类占用的内存区域,这样就可以访问它的数据,无论是打开还是关闭...
该类没有“获得访问权限”,它用自己替换了另一个类的对象。或者更确切地说,甚至不是对象,而是指向另一个类的对象的指针,声明为指向其类对象的指针——具有相同的内部结构。
粗略地说,伪造护照:)
这里的一切都是微不足道的,这可能是没有解释的原因。
该类
Stealer只是将类型对象的内存重新解释PrivateClass为类型对象的内存Stealer。类域的位置Stealer,按照思路,应该和类域的位置相匹配PrivateClass。也就是说,按照思路,经过这样的重新解释,通过类的字段查找Stealer,我们就会在内存中“看到”类对应的字段PrivateClass。这些技巧违反了 C++ 语言的严格别名要求。该代码会产生未定义的行为,并且通常无法操作。
PS 一个让你合法绕过
private我在这里提供的保护的技巧:https ://ru.stackoverflow.com/a/656542/182825 。适用于这种情况:http ://coliru.stacked-crooked.com/a/49db7cfe2b1bc36b