为什么我可以通过指向派生对象的基类指针访问派生私有成员函数？
#include<iostream>
using namespace std;
class base
{
public:
virtual void add() {
cout << "hi";
}
};
class derived : public base
{
private:
void add() {
cout << "bye";
}
};
int main()
{
base *ptr;
ptr = new derived;
ptr->add();
return 0;
}
输出是 bye
我对如何实现没有问题。我知道您使用 vtable，并且导出的 vtable 包含新 add() 函数的地址。但是 add() 是私有的，当我尝试在类之外访问它时，编译器不应该生成错误吗？不知怎的，这似乎不太对劲。
#include<iostream>
using namespace std;
class base
{
public:
virtual void add() {
cout << "hi";
}
};
class derived : public base
{
private:
void add() {
cout << "bye";
}
};
int main()
{
base *ptr;
ptr = new derived;
ptr->add();
return 0;
}
Output is bye
I dont have a problem with how this is implemented. I understand you use vtables and the vtable of derived contains the address of the new add() function. But add() is private shouldn't compiler generate an error when I try to access it outside the class? Somehow it doesn't seem right.
如果你对这篇内容有疑问，欢迎到本站社区发帖提问 参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。
绑定邮箱获取回复消息
由于您还没有绑定你的真实邮箱，如果其他用户或者作者回复了您的评论，将不能在第一时间通知您！
发布评论
评论（3）
add()仅在派生中是私有的，但您拥有的静态类型 是base*- 因此访问base的限制适用。一般来说，您甚至无法在编译时知道指向
base的指针的动态类型是什么，它可能会根据用户输入而改变。这是根据C++03 §11.6：
add()is only private inderived, but the static type you have isbase*- thus the access restrictions ofbaseapply.In general you can't even know at compile time what the dynamic type of a pointer to
basewill be, it could e.g. change based on user input.This is per C++03 §11.6:
访问修饰符，例如
public、private和protected仅在编译期间强制执行。当您通过指向基类的指针调用该函数时，编译器不知道该指针指向派生类的实例。根据编译器可以从这个表达式推断出的规则，这个调用是有效的。降低派生类中成员的可见性通常是语义错误。现代编程语言（例如 Java 和 C#）拒绝编译此类代码，因为在基类中可见的成员始终可以通过基指针在派生类中访问。
Access modifiers, such as
public,privateandprotectedare only enforced during compilation. When you call the function through a pointer to the base class, the compiler doesn't know that the pointer points to an instance of the derived class. According to the rules the compiler can infer from this expression, this call is valid.It is usually a semantic error to reduce the visibility of a member in a derived class. Modern programming languages such as Java and C# refuse to compile such code, because a member that is visible in the base class is always accessible in the derived class through a base pointer.
对 Georg 的答案补充一点：
请记住，编译器无法控制也不能保证派生类的任何内容。例如，我可以将我的类型发送到库中，并在一个全新的程序中从中派生。库编译器应该如何知道派生可能具有不同的访问说明符？编译库时派生类型不存在。
为了支持这一点，编译器必须在运行时知道访问说明符，并在您尝试访问私有成员时抛出异常。
To add a little to Georg's answer:
Remember that the compiler has no control over and cannot guarantee anything about derived classes. For example, I could ship my type in a library and derive from it in an entirely new program. How is the library compiler supposed to know that derived might have a different access specifier? The derived type didn't exist when the library was compiled.
In order to support this, the compiler would have to know access specifiers at runtime and throw an exception if you attempted to access a private member.