C++基于用户输入初始化类及多实现代码复用方案咨询

嘿，我来帮你理清这个多态实现的思路，还有你问的基于事件初始化类的问题～

一、用虚函数基类实现多态，避免代码重复 #

你这个思路完全正确，通过基类定义统一接口，子类实现具体逻辑，就能最大化复用代码。下面给你写个完整的可运行示例：

首先定义基类，注意析构函数要声明为虚函数，否则子类对象通过基类指针销毁时会有内存泄漏：

#include <iostream>
#include <memory> // 用于智能指针
#include <string>

// 基类：定义统一接口
class Method {
public:
    // 虚析构函数，确保子类析构被正确调用
    virtual ~Method() = default;
    // 纯虚函数，子类必须实现的核心任务逻辑
    virtual void execute() const = 0;
};

// 子类1：具体实现方式1
class Method1 : public Method {
public:
    void execute() const override {
        std::cout << "使用方法1执行任务，采用XX数据结构优化场景A\n";
    }
};

// 子类2：具体实现方式2
class Method2 : public Method {
public:
    void execute() const override {
        std::cout << "使用方法2执行任务，采用YY数据结构优化场景B\n";
    }
};

// 子类3：具体实现方式3
class Method3 : public Method {
public:
    void execute() const override {
        std::cout << "使用方法3执行任务，采用ZZ数据结构优化场景C\n";
    }
};

然后在main函数里，根据用户输入创建对应子类对象，调用统一接口：

int main() {
    std::cout << "请选择执行方法（1/2/3）：";
    int choice;
    std::cin >> choice;

    // 使用智能指针管理对象，避免手动释放内存
    std::unique_ptr<Method> method_ptr;

    // 根据用户选择初始化对应子类
    switch(choice) {
        case 1:
            method_ptr = std::make_unique<Method1>();
            break;
        case 2:
            method_ptr = std::make_unique<Method2>();
            break;
        case 3:
            method_ptr = std::make_unique<Method3>();
            break;
        default:
            std::cerr << "无效选择！\n";
            return 1;
    }

    // 调用统一接口，自动执行子类的具体逻辑
    method_ptr->execute();

    return 0;
}

这个写法的好处是，以后要加新的实现方式，只需要新增一个继承Method的子类，修改switch分支即可，原有代码完全不用动，符合开闭原则。

二、基于事件初始化类的实现 #

所谓“基于事件初始化类”，就是当某个特定事件发生时，才创建对应的子类实例，而不是程序启动就初始化。比如事件可以是用户点击按钮、收到网络消息、满足某个业务条件等等。

举个简单的例子，假设我们有个“用户点击按钮”的事件，触发时初始化对应子类：

// 模拟事件触发函数，比如GUI按钮的点击回调
void onButtonClick(int button_id) {
    std::unique_ptr<Method> method_ptr;

    // 根据事件类型（按钮ID）初始化对应子类
    switch(button_id) {
        case 101: // 按钮1对应方法1
            method_ptr = std::make_unique<Method1>();
            break;
        case 102: // 按钮2对应方法2
            method_ptr = std::make_unique<Method2>();
            break;
        case 103: // 按钮3对应方法3
            method_ptr = std::make_unique<Method3>();
            break;
        default:
            std::cerr << "未知按钮事件！\n";
            return;
    }

    method_ptr->execute();
}

// 在main里模拟事件触发
int main() {
    // 模拟用户点击了ID为102的按钮
    onButtonClick(102);
    return 0;
}

如果是更复杂的事件系统，比如用观察者模式，你可以把事件监听和类初始化逻辑绑定：当事件被触发时，观察者的回调函数里创建对应的子类实例并执行任务。核心思路就是把类的实例化逻辑从程序启动阶段，延迟到事件发生的时机。

另外，如果你想更优雅地管理子类的创建，可以把switch分支抽成一个工厂函数，比如：

std::unique_ptr<Method> createMethod(int type) {
    switch(type) {
        case 1: return std::make_unique<Method1>();
        case 2: return std::make_unique<Method2>();
        case 3: return std::make_unique<Method3>();
        default: return nullptr;
    }
}

这样不管是用户输入还是事件触发，都可以调用这个工厂函数来创建对象，进一步减少代码重复。

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