设计模式代码

1. 策略模式（Strategy Pattern）

当任务类型很多、参数配置复杂时，可以使用策略模式来分离任务的不同配置或执行策略。这将允许你在不同的任务之间动态切换任务的行为。

例如，如果你的任务有多种执行方式（例如不同单位的任务处理、不同的结果保存方式），你可以为每种方式定义一个策略接口，并在具体任务中动态选择合适的策略。

示例：

class TaskStrategy {
public:
    virtual void execute() = 0;  // 执行任务
};

class MetricTaskStrategy : public TaskStrategy {
public:
    void execute() override {
        // 处理米为单位的任务
    }
};

class ImperialTaskStrategy : public TaskStrategy {
public:
    void execute() override {
        // 处理英制单位的任务
    }
};

class Task {
private:
    TaskStrategy *strategy;  // 持有策略对象

public:
    void setStrategy(TaskStrategy *strategy) {
        this->strategy = strategy;
    }

    void runTask() {
        strategy->execute();  // 根据策略执行任务
    }
};

2. 工厂方法模式（Factory Method Pattern）

如果你的任务类型很复杂，且每个任务类型的参数不同，使用工厂方法模式可以简化任务对象的创建。你可以根据不同的任务类型创建对应的 TaskParameters 实例，避免每次手动创建具体的任务对象。

示例：

class TaskFactory {
public:
    static TaskParameters* createTask(const QString &taskType) {
        if (taskType == "Metric") {
            return new TaskParameters(/* 设置米为单位的参数 */);
        } else if (taskType == "Imperial") {
            return new TaskParameters(/* 设置英制单位的参数 */);
        }
        return nullptr;
    }
};

3. 单例模式（Singleton Pattern）

任务管理器可以作为一个全局的任务配置管理类，使用单例模式保证全局只有一个实例。这样你可以避免在应用程序中创建多个任务管理对象，保持配置参数的统一。

示例：

class TaskManager {
private:
    static TaskManager *instance;
    TaskManager() {}  // 私有构造函数

public:
    static TaskManager* getInstance() {
        if (instance == nullptr) {
            instance = new TaskManager();
        }
        return instance;
    }

    // 任务管理方法
    void saveTaskTemplate(const TaskParameters &task, const QString &filename) {
        task.saveToFile(filename);
    }

    // 其他任务方法...
};

TaskManager* TaskManager::instance = nullptr;

4. 观察者模式（Observer Pattern）

如果你有多个界面或组件需要响应任务参数的变化，可以使用观察者模式。当任务参数发生变化时，所有需要更新的界面或模块都会自动得到通知，并做出响应。比如，某个界面修改了参数，其他界面（例如显示结果或更新单位）可以自动刷新。

示例：

class TaskParametersObserver {
public:
    virtual void update() = 0;  // 更新方法
};

class TaskParameters {
private:
    QList<TaskParametersObserver*> observers;

public:
    void addObserver(TaskParametersObserver* observer) {
        observers.append(observer);
    }

    void notifyObservers() {
        for (TaskParametersObserver* observer : observers) {
            observer->update();  // 通知所有观察者
        }
    }

    void changeParameter() {
        // 当参数改变时
        notifyObservers();
    }
};

5. 命令模式（Command Pattern）

如果任务有多个复杂的操作，可以使用命令模式将任务的操作封装为命令对象。这些命令对象可以在需要时按顺序执行，方便管理任务执行的逻辑和回滚操作。

示例：

class Command {
public:
    virtual void execute() = 0;  // 执行命令
};

class RunTaskCommand : public Command {
private:
    Task *task;

public:
    RunTaskCommand(Task *task) : task(task) {}

    void execute() override {
        task->runTask();
    }
};

6. 状态模式（State Pattern）

如果任务的执行过程是有多个不同状态的（比如初始化、运行中、完成等），你可以使用状态模式。每个状态可以有不同的行为，使得任务的状态管理更加清晰和可维护。

示例：

class TaskState {
public:
    virtual void handle() = 0;  // 处理状态
};

class InitializedState : public TaskState {
public:
    void handle() override {
        // 初始化状态下的处理
    }
};

class RunningState : public TaskState {
public:
    void handle() override {
        // 运行状态下的处理
    }
};

class Task {
private:
    TaskState *state;

public:
    void setState(TaskState *state) {
        this->state = state;
    }

    void run() {
        state->handle();
    }
};

总结：

对于你的应用程序，使用以下设计模式可能最为合适：

1. 策略模式：如果任务的执行有多种不同的方式或策略（如不同单位的处理方式），可以使用策略模式。
2. 工厂方法模式：用于创建不同类型的任务参数和任务对象，可以简化任务的实例化。
3. 单例模式：任务管理器使用单例模式来确保全局只有一个任务管理实例，方便管理和保存模板。
4. 观察者模式：如果有多个界面需要响应任务参数的变化，使用观察者模式来自动更新相关界面。
5. 命令模式：当任务的执行过程有多个复杂操作时，可以使用命令模式来封装这些操作。
6. 状态模式：如果任务有多个状态（例如：初始化、执行中、完成等），使用状态模式来管理任务状态。

选择适合的设计模式可以帮助你更好地管理任务参数、执行过程和任务模板，提升程序的灵活性和可维护性。

---

来源：CSDN 原文，首次发布于 2025-03-26。