【C++】私有虚函数与多态：访问权限不影响动态绑定

#include <iostream>
using namespace std;

class A
{
public: 
    virtual void f()
    {
        cout << "A::f()" << endl;
    }
};

class B : public A
{
private:
    virtual void f()  // 私有重写基类的虚函数
    {
        cout << "B::f()" << endl;
    }
};

int main()
{
    A* pa = (A*)new B;  // 创建B对象，用A*指针指向它
    pa->f();             // 通过基类指针调用虚函数
    delete pa;
    return 0;
}

执行过程分析

1. 编译阶段

编译器看到pa->f()，检查pa的静态类型A*
在类A中查找f()函数，发现它是public虚函数
编译通过，生成调用虚函数的代码（通过虚表查找）

2. 运行时阶段

pa实际指向B对象
通过pa找到对象的虚表指针
从虚表中找到函数地址并调用
由于B重写了f()，虚表中存储的是B::f()的地址
因此实际调用的是B::f()

关键点解释

虚表覆盖机制

text

复制代码

A类虚表：
+-----------+
| &A::f()   |
+-----------+

B类虚表（继承自A的部分）：
+-----------+
| &B::f()   |  // 用B::f()的地址覆盖了A::f()的地址
+-----------+

访问权限与多态的关系

访问权限是编译时检查：编译器根据变量的静态类型检查是否有权访问成员
多态是运行时绑定：通过虚表机制在运行时确定调用哪个函数
两者是独立的机制，互不干扰

为什么这样设计？

1. 封装性

派生类可以选择将重写的虚函数设为私有，实现更好的封装：

cpp

复制代码

class B : public A
{
private:
    virtual void f() override
    {
        // 内部实现细节，外部不可直接调用
        doSomething();
        A::f();  // 可选择调用基类实现
    }
};

2. 接口与实现分离

基类定义公共接口（public虚函数）
派生类提供具体实现，可以控制访问权限
外部只能通过基类接口访问，无法直接调用派生类的私有函数

3. 设计灵活性

cpp

复制代码

class Database {
public:
    virtual void connect() = 0;  // 公共接口
};

class SecureDatabase : public Database {
private:
    virtual void connect() override  // 私有实现
    {
        authenticate();
        establishSecureConnection();
    }
    
    void authenticate() { /* 认证逻辑 */ }
};

重要注意事项

1. 不能直接调用私有虚函数

cpp

复制代码

B b;
b.f();  // 错误：B::f()是私有的

A* p = &b;
p->f(); // 正确：通过基类接口调用

2. 构造函数中的虚函数调用

cpp

复制代码

class Base {
public:
    Base() { f(); }  // 这里调用的是Base::f()，不是多态
    virtual void f() { cout << "Base" << endl; }
};

class Derived : public Base {
private:
    virtual void f() override { cout << "Derived" << endl; }
};

Derived d;  // 输出："Base"，因为在构造函数中虚函数机制不完整

3. 析构函数中的虚函数调用

cpp

复制代码

class Base {
public:
    virtual ~Base() { f(); }
    virtual void f() { cout << "Base" << endl; }
};

class Derived : public Base {
private:
    virtual void f() override { cout << "Derived" << endl; }
    ~Derived() { }
};

Base* p = new Derived;
delete p;  // 输出："Derived"，多态正常生效

实际应用场景

1. 模板方法模式

cpp

复制代码

class Algorithm {
public:
    void run() {        // 公共模板方法
        init();
        execute();
        cleanup();
    }
    
protected:
    virtual void init() = 0;      // 派生类实现
    virtual void execute() = 0;   // 派生类实现
    
private:
    virtual void cleanup() {      // 私有虚函数，派生类可重写
        // 默认清理逻辑
    }
};

2. 非公有重写

cpp

复制代码

class Window {
public:
    virtual void draw() { /* 默认绘制 */ }
};

class FancyWindow : public Window {
private:
    virtual void draw() override {  // 私有重写，禁止外部直接调用
        prepareGraphics();
        Window::draw();  // 调用基类实现
        addEffects();
    }
};

问题答案

对于题目中的代码：

cpp

复制代码

A* pa = (A*)new B;
pa->f();

输出结果是： B::f()

总结

多态与访问权限无关：虚函数的重写不受访问权限限制
编译时与运行时分离：访问权限在编译时检查，虚函数绑定在运行时决定
设计意义：允许派生类隐藏实现细节，同时保持多态行为
实际应用：常用于模板方法模式、接口实现等场景

在C++中，当派生类重写基类的虚函数时，即使派生类中的虚函数是private访问权限，它仍然会覆盖基类中public的虚函数（假设基类虚函数是public）。多态机制是通过虚函数表（vtable）实现的，派生类的虚函数地址会覆盖虚表中对应基类虚函数的槽位。当通过基类指针调用虚函数时，实际调用的是派生类的函数版本，而不管该函数在派生类中的访问权限是public、protected还是private。这是因为访问权限是在编译阶段检查的，而多态调用是在运行时通过虚表解析的。但是，注意：我们是通过基类指针调用虚函数，而基类中的虚函数是public，所以编译时检查是通过的（因为基类指针类型认为它调用的是基类的public虚函数）。运行时实际调用的是派生类的私有虚函数，但这是允许的，因为访问控制不适用于动态绑定。

所以，对于给定的代码：

基类A有public虚函数f。
派生类B私有重写了虚函数f（仍然是虚函数，即使没有写virtual关键字，因为基类是virtual，但这里写了virtual）。
创建B对象，并将其地址赋给A指针pa（注意：这里用了C风格转换(A )，但new B返回的就是B*，可以隐式转换为A*，所以这个转换是多余的，但合法）。
通过pa->f()调用虚函数。

因为pa的静态类型是A*，而A中的f是public，所以编译时检查通过。运行时，由于pa实际指向B对象，虚表被覆盖为B::f的地址，所以调用的是B::f。尽管B::f是private，但这不影响调用，因为它是通过基类接口调用的，而基类接口是public。所以输出应该是"B::f()"。

因此，输出结果是"B::f()"。

理解这一点对于掌握C++多态机制和面向对象设计非常重要。它体现了C++"信任程序员"的设计哲学，给予开发者更大的灵活性，同时也要求开发者对语言机制有深入理解。