设计模式在 C++ 面向对象开发中的应用

#include <iostream>
#include <memory>
#include <string>

// 基类
class Shape {
public:
    virtual void draw() const = 0;
    virtual ~Shape() = default;
};

// 具体类
class Circle : public Shape {
public:
    void draw() const override {
        std::cout << "Drawing a Circle" << std::endl;
    }
};

class Rectangle : public Shape {
public:
    void draw() const override {
        std::cout << "Drawing a Rectangle" << std::endl;
    }
};

// 工厂类
class ShapeFactory {
public:
    std::unique_ptr<Shape> getShape(const std::string& shapeType) {
        if (shapeType == "CIRCLE") {
            return std::make_unique<Circle>();
        } else if (shapeType == "RECTANGLE") {
            return std::make_unique<Rectangle>();
        }
        return nullptr;
    }
};

int main() {
    ShapeFactory shapeFactory;
    auto shape1 = shapeFactory.getShape("CIRCLE");
    shape1->draw();
    auto shape2 = shapeFactory.getShape("RECTANGLE");
    shape2->draw();
    return 0;
}

观察者模式（Observer）

观察者模式用于实现对象之间的依赖关系，当一个对象的状态发生变化时，所有依赖于它的对象都会自动更新。该模式非常适合实现事件驱动的系统，例如 GUI 应用程序中的事件监听机制。通过观察者模式，可以实现低耦合的设计，使得系统的扩展更加灵活。

#include <iostream>
#include <vector>
#include <string>

// 抽象观察者
class Observer {
public:
    virtual void update(const std::string& message) = 0;
    virtual ~Observer() = default;
};

// 抽象主题
class Subject {
private:
    std::vector<Observer*> observers;

public:
    void attach(Observer* observer) {
        observers.push_back(observer);
    }

    void detach(Observer* observer) {
        observers.erase(std::remove(observers.begin(), observers.end(), observer), observers.end());
    }

    void notify(const std::string& message) {
        for (auto observer : observers) {
            observer->update(message);
        }
    }
};

// 具体观察者
class ConcreteObserver : public Observer {
public:
    void update(const std::string& message) override {
        std::cout << "Observer received message: " << message << std::endl;
    }
};

int main() {
    Subject subject;
    ConcreteObserver observer1, observer2;
    subject.attach(&observer1);
    subject.attach(&observer2);
    subject.notify("Hello Observers!");
    subject.detach(&observer1);
    subject.notify("Observer1 detached.");
    return 0;
}

策略模式（Strategy）

策略模式用于定义一系列算法，并将它们封装在独立的类中。通过将算法封装在独立的类中，使得算法可以独立于客户端代码进行扩展和修改。这种方式不仅提高了代码的可维护性，还使得算法的切换更加灵活。

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

// 抽象策略
class SortStrategy {
public:
    virtual void sort(std::vector<int>& data) const = 0;
    virtual ~SortStrategy() = default;
};

// 具体策略：冒泡排序
class BubbleSort : public SortStrategy {
public:
    void sort(std::vector<int>& data) const override {
        for (size_t i = 0; i < data.size(); ++i) {
            for (size_t j = 0; j < data.size() - i - 1; ++j) {
                if (data[j] > data[j + 1]) {
                    std::swap(data[j], data[j + 1]);
                }
            }
        }
    }
};

// 具体策略：快速排序
class QuickSort : public SortStrategy {
public:
    void sort(std::vector<int>& data) const override {
        std::sort(data.begin(), data.end());
    }
};

// 上下文类
class Sorter {
private:
    SortStrategy* strategy;

public:
    Sorter(SortStrategy* strategy) : strategy(strategy) {}

    void setStrategy(SortStrategy* strategy) {
        this->strategy = strategy;
    }

    void sort(std::vector<int>& data) {
        strategy->sort(data);
    }
};

int main() {
    std::vector<int> data = {5, 2, 9, 1, 5, 6};
    Sorter sorter(new BubbleSort());
    sorter.sort(data);
    std::cout << "Sorted data (Bubble Sort): ";
    for (int num : data) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    sorter.setStrategy(new QuickSort());
    sorter.sort(data);
    std::cout << "Sorted data (Quick Sort): ";
    for (int num : data) {
        std::cout << num << " ";
    }
    std::cout << std::endl;
    return 0;
}

设计模式的实际应用价值

灵活性

设计模式提供了一种灵活的解决方案，能够帮助开发者解决常见的设计问题。例如，工厂模式通过封装对象的创建逻辑，使得代码更加灵活和可扩展；观察者模式通过解耦对象之间的依赖关系，使得系统的扩展更加灵活。

提升代码的可维护性

设计模式通过面向对象的思想，将复杂的逻辑封装在独立的类中，使得代码更加清晰和易于维护。例如，策略模式通过将算法封装在独立的类中，使得算法的修改和扩展不会影响客户端代码。

面向对象设计原则的应用

面向对象设计的一些基本原则，如单一职责原则、开闭原则、里氏替换原则等，为设计模式的应用提供了指导，帮助开发者设计出更合理、更灵活的系统。

实战案例：任务调度系统

在实际项目中，可以将所学知识应用到任务调度系统中，管理任务的创建、执行和通知机制。通过工厂模式和观察者模式来实现这一功能。

工厂模式的应用

使用工厂模式来创建任务对象。任务对象的类型可以根据任务的类型动态决定。

#include <iostream>
#include <memory>
#include <string>

// 基类
class Task {
public:
    virtual void execute() const = 0;
    virtual ~Task() = default;
};

// 具体任务
class EmailTask : public Task {
public:
    void execute() const override {
        std::cout << "Sending email..." << std::endl;
    }
};

class FileTask : public Task {
public:
    void execute() const override {
        std::cout << "Processing file..." << std::endl;
    }
};

// 工厂类
class TaskFactory {
public:
    std::unique_ptr<Task> createTask(const std::string& taskType) {
        if (taskType == "EMAIL") {
            return std::make_unique<EmailTask>();
        } else if (taskType == "FILE") {
            return std::make_unique<FileTask>();
        }
        return nullptr;
    }
};

int main() {
    TaskFactory taskFactory;
    auto task1 = taskFactory.createTask("EMAIL");
    task1->execute();
    auto task2 = taskFactory.createTask("FILE");
    task2->execute();
    return 0;
}

观察者模式的应用

使用观察者模式来实现任务状态变化的通知机制。任务对象作为主题，观察者可以注册到任务对象上，并在任务状态变化时接收通知。

#include <iostream>
#include <vector>
#include <string>

// 抽象观察者
class Observer {
public:
    virtual void update(const std::string& message) = 0;
    virtual ~Observer() = default;
};

// 抽象主题
class Subject {
private:
    std::vector<Observer*> observers;

public:
    void attach(Observer* observer) {
        observers.push_back(observer);
    }

    void detach(Observer* observer) {
        observers.erase(std::remove(observers.begin(), observers.end(), observer), observers.end());
    }

    void notify(const std::string& message) {
        for (auto observer : observers) {
            observer->update(message);
        }
    }
};

// 具体主题：任务
class TaskSubject : public Subject {
private:
    std::string status;

public:
    void setStatus(const std::string& newStatus) {
        status = newStatus;
        notify("Task status changed to: " + status);
    }
};

// 具体观察者
class TaskObserver : public Observer {
public:
    void update(const std::string& message) override {
        std::cout << "Observer received message: " << message << std::endl;
    }
};

int main() {
    TaskSubject task;
    TaskObserver observer1, observer2;
    task.attach(&observer1);
    task.attach(&observer2);
    task.setStatus("RUNNING");
    task.setStatus("COMPLETED");
    task.detach(&observer1);
    task.setStatus("FAILED");
    return 0;
}

总结

设计模式是构建高质量软件架构的重要工具。通过应用单例、工厂、观察者和策略等模式，可以有效提升系统的灵活性、可维护性和可扩展性。结合面向对象设计原则，开发者能够设计出更加合理且易于演进的代码结构。