C++中能否避免为大量Screen子类创建头文件？

我定义了如下抽象类Screen：

class Screen {
public:
    virtual void init() = 0;
    virtual void update(float dt) = 0;
    virtual void handleInputs(ScreenManager* screenManager) = 0;
    virtual void dispose() = 0;
};

每次创建新的Screen子类时，我都需要完成两步操作：

1. 创建头文件，示例如下：

class MenuScreen : public Screen {
public:
    void init() override;
    void update(float dt) override;
    void handleInputs(ScreenManager* screenManager) override;
    void dispose() override;
};

2. 创建cpp文件，示例如下：

void MenuScreen::init() {

}

void MenuScreen::update(float dt) {
    
}

void MenuScreen::handleInputs(ScreenManager* screenManager) {
    
}

void MenuScreen::dispose() {

}

目前我需要创建大量Screen子类，每次都要复制粘贴模板仅修改类名，请问是否有更优的实现方式？我的当前做法是否合理？恳请提供解决方案。

当前做法的合理性 #

你的当前做法是合理的，这是C++中实现纯虚函数子类的标准流程，能确保每个子类都明确覆盖所有接口方法，避免遗漏。但子类数量过多时，重复复制粘贴会降低效率，也容易出现拼写错误。

优化方案 #

1. 利用IDE自定义代码模板 #

主流C++ IDE（VSCode、CLion、Visual Studio等）都支持自定义代码模板：

• 针对头文件：创建包含子类继承Screen结构的模板，将类名设为可替换变量
• 针对cpp文件：创建对应模板，自动生成所有虚函数的空实现，类名同样设为可替换变量
  使用时只需输入模板快捷键，填入类名即可自动生成完整的头文件和cpp文件，大幅减少重复操作。

2. 定义带默认实现的中间基类 #

如果大部分子类的某些方法（比如init、dispose）逻辑为空或有通用默认行为，可以定义一个中间类提供这些方法的默认实现，让子类只重写有差异的方法：

// 中间基类
class BaseScreen : public Screen {
public:
    void init() override {}
    void dispose() override {}
    // 保留update和handleInputs为纯虚，适配子类差异化逻辑
    virtual void update(float dt) = 0;
    virtual void handleInputs(ScreenManager* screenManager) = 0;
};

后续创建子类时只需继承BaseScreen，仅实现需要自定义的方法：

// 头文件
class MenuScreen : public BaseScreen {
public:
    void update(float dt) override;
    void handleInputs(ScreenManager* screenManager) override;
};

// cpp文件
void MenuScreen::update(float dt) {
    // 自定义更新逻辑
}

void MenuScreen::handleInputs(ScreenManager* screenManager) {
    // 自定义输入处理逻辑
}

3. 编写代码生成脚本 #

如果IDE模板不够灵活，可以用Python/Bash写一个简单脚本，接收类名参数自动生成文件。示例Python脚本：

import sys

def generate_screen(class_name):
    # 生成头文件
    header_content = f"""class {class_name} : public Screen {{
public:
    void init() override;
    void update(float dt) override;
    void handleInputs(ScreenManager* screenManager) override;
    void dispose() override;
}};
"""
    with open(f"{class_name}.h", "w") as f:
        f.write(header_content)
    
    # 生成cpp文件
    cpp_content = f"""void {class_name}::init() {{

}}

void {class_name}::update(float dt) {{
    
}}

void {class_name}::handleInputs(ScreenManager* screenManager) {{
    
}}

void {class_name}::dispose() {{

}}
"""
    with open(f"{class_name}.cpp", "w") as f:
        f.write(cpp_content)

if __name__ == "__main__":
    if len(sys.argv) != 2:
        print("Usage: python generate_screen.py ClassName")
    else:
        generate_screen(sys.argv[1])

运行python generate_screen.py MenuScreen即可自动生成对应文件。

4. 进阶：使用CRTP（奇异递归模板模式） #

如果需要给所有子类注入通用前置/后置逻辑（如日志、状态检查），可以用CRTP：

template<typename Derived>
class CRTPScreen : public Screen {
public:
    void init() override {
        // 通用前置逻辑
        static_cast<Derived*>(this)->initImpl();
        // 通用后置逻辑
    }
    void update(float dt) override {
        static_cast<Derived*>(this)->updateImpl(dt);
    }
    // 其他方法类似
};

// 子类实现
class MenuScreen : public CRTPScreen<MenuScreen> {
public:
    void initImpl() {
        // 自定义初始化逻辑
    }
    void updateImpl(float dt) {
        // 自定义更新逻辑
    }
    // 实现其他Impl方法
};

这种方式适合有通用逻辑的场景，单纯减少代码量的话前三种方法更直接。

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