如何通过父类虚函数自动调用所有子类的重写函数？

假设我有parent类，其子类为child1、child2和child3，所有子类均继承并重写了parent类的TellName虚函数。我想知道是否存在一种方法，调用parent类的TellName函数时，能自动执行child1、child2和child3的TellName函数。

代码示例 #

class parent
{
public:
    virtual void TellName() { }
};

class child1 : public parent
{
public:
    void TellName() override { std::cout<<"Child1"<<"\n"; }
};

class child2 : public parent
{
public:
    void TellName() override { std::cout<<"Child2"<<"\n"; }
};

class child3 : public parent
{
public:
    void TellName() override { std::cout<<"Child3"<<"\n"; }
};

期望输出 #

Child1
Child2
Child3

我原本猜测可以通过TellName函数的VTable实现，希望我的表述清晰。

直接通过父类对象调用虚函数无法自动触发所有子类的实现——C++的虚函数机制是基于具体对象的实际类型实现动态多态，只会调用当前对象所属类的重写函数，不会遍历所有子类。但可以通过以下两种方式实现你的需求：

方法1：维护子类实例注册表 #

在父类中维护一个静态的子类实例列表，每个子类构造时自动注册到列表中，父类提供一个静态方法遍历列表，调用每个实例的TellName：

#include <iostream>
#include <vector>
#include <algorithm>

class parent
{
private:
    static std::vector<parent*>& getInstances() {
        static std::vector<parent*> instances;
        return instances;
    }
protected:
    // 保护构造函数，禁止直接实例化父类
    parent() {
        getInstances().push_back(this);
    }
public:
    virtual void TellName() { }
    
    // 调用所有已注册子类实例的TellName
    static void CallAllTellName() {
        for (auto inst : getInstances()) {
            inst->TellName();
        }
    }
    
    virtual ~parent() {
        // 析构时从注册表移除当前实例
        auto& instances = getInstances();
        auto it = std::find(instances.begin(), instances.end(), this);
        if (it != instances.end()) {
            instances.erase(it);
        }
    }
};

class child1 : public parent
{
public:
    void TellName() override { std::cout<<"Child1"<<"\n"; }
};

class child2 : public parent
{
public:
    void TellName() override { std::cout<<"Child2"<<"\n"; }
};

class child3 : public parent
{
public:
    void TellName() override { std::cout<<"Child3"<<"\n"; }
};

// 使用示例
int main() {
    child1 c1;
    child2 c2;
    child3 c3;
    
    parent::CallAllTellName();
    return 0;
}

方法2：编译期注册子类类型（模板元编程） #

如果不需要保留子类实例，只想调用每个子类的TellName实现，可以用C++17的折叠表达式在编译期遍历指定的子类类型，创建临时实例并调用函数：

#include <iostream>
#include <memory>

class parent
{
public:
    virtual void TellName() { }
    virtual ~parent() = default;
};

class child1 : public parent
{
public:
    void TellName() override { std::cout<<"Child1"<<"\n"; }
};

class child2 : public parent
{
public:
    void TellName() override { std::cout<<"Child2"<<"\n"; }
};

class child3 : public parent
{
public:
    void TellName() override { std::cout<<"Child3"<<"\n"; }
};

// 编译期遍历子类类型并调用TellName
template<typename... Children>
struct CallAllTellName {
    static void run() {
        // 折叠表达式，依次处理每个子类类型
        ([](){
            std::unique_ptr<parent> p = std::make_unique<Children>();
            p->TellName();
        }(), ...);
    }
};

// 使用示例
int main() {
    CallAllTellName<child1, child2, child3>::run();
    return 0;
}

关于VTable的说明 #

你提到的VTable是C++实现动态多态的底层机制，但每个类的VTable只包含自身的虚函数入口，父类的VTable不会自动包含所有子类的重写函数——编译器不会在编译期跟踪所有继承自父类的子类，因此无法直接通过VTable实现遍历调用所有子类的需求，必须手动实现注册逻辑。

内容的提问来源于stack exchange，提问作者Hassan