C++模板类与多态结合实现通用接口

#include <iostream>
#include <memory>
#include <vector>

// 1. 非模板的抽象基类：定义多态接口
class ICommand {
public:
    virtual ~ICommand() = default;
    virtual void execute() = 0;
};

// 2. 模板类：实现多态接口，并封装特定类型的数据和操作
template<typename T>
class ConcreteCommand : public ICommand {
private:
    T data_;
    void (*action_)(T&); // 函数指针，用于执行特定操作

public:
    ConcreteCommand(T data, void (*action)(T&))
        : data_(std::move(data)), action_(action) {}

    void execute() override {
        if (action_) {
            action_(data_);
        }
    }
};

// 具体的函数，用于演示
void printInt(int& val) {
    std::cout << "Printing int: " << val << std::endl;
}

void processString(std::string& str) {
    std::cout << "Processing string: " << str << ", length: " << str.length() << std::endl;
}

// 示例用法
// int main() {
//     std::vector<std::unique_ptr<ICommand>> commands;

//     commands.push_back(std::make_unique<ConcreteCommand<int>>(10, printInt));
//     commands.push_back(std::make_unique<ConcreteCommand<std::string>>("hello world", processString));
//     commands.push_back(std::make_unique<ConcreteCommand<int>>(20, printInt));

//     for (const auto& cmd : commands) {
//         cmd->execute();
//     }

//     return 0;
// }

ICommand

execute()

ConcreteCommand<T>

T

std::vector<std::unique_ptr<ICommand>>

execute()

std::vector<MyTemplate<int>>

std::vector<MyTemplate<std::string>>

virtual ~ICommand() = default;

ConcreteCommand<T>

T

ICommand

T

std::function

T

std::function

ConcreteCommand

// 辅助工厂函数
template<typename T, typename Func>
std::unique_ptr<ICommand> make_command(T data, Func action) {
    // std::function 提供了更强的灵活性
    return std::make_unique<ConcreteCommand<T>>(std::move(data),
                                                 static_cast<void(*)(T&)>(action));
}
// 注意：如果action是lambda或std::function，直接用函数指针会报错
// 更通用的方式是修改ConcreteCommand，使其内部使用std::function
// template<typename T, typename Func>
// class ConcreteCommand : public ICommand {
// private:
//     T data_;
//     std::function<void(T&)> action_;
// public:
//     ConcreteCommand(T data, Func action)
//         : data_(std::move(data)), action_(std::move(action)) {}
//     void execute() override {
//         if (action_) {
//             action_(data_);
//         }
//     }
// };
// 那么make_command就可以直接是：
// template<typename T, typename Func>
// std::unique_ptr<ICommand> make_command(T data, Func action) {
//     return std::make_unique<ConcreteCommand<T, Func>>(std::move(data), std::move(action));
// }

T

action

std::unique_ptr

std::shared_ptr

ICommand