本文介绍了 C++ 面向对象开发中四种常用设计模式的应用。包括单例模式确保类仅有一个实例并提供全局访问点；工厂模式封装对象创建逻辑，提升扩展性；观察者模式实现对象间依赖解耦，适用于事件驱动系统；策略模式将算法封装在独立类中，便于切换。通过实战案例展示了这些模式在任务调度系统等项目中的具体实现，强调了设计模式对代码可维护性和灵活性的价值。
设计模式是面向对象编程中的一种最佳实践，能够帮助开发者解决常见的设计问题，提升代码的可维护性和可扩展性。以下是关于设计模式在 C++ 开发中应用的笔记和心得。
课程中详细讲解了几种常用的设计模式，包括单例模式（Singleton）、工厂模式（Factory）、观察者模式（Observer）和策略模式（Strategy）。这些设计模式不仅解决了实际开发中的常见问题，还通过面向对象的思想提升了代码的可扩展性和可维护性。
单例模式是设计模式中最简单的一种，它确保一个类只有一个实例，并提供一个全局访问点。以下代码展示了单例模式的实现：
#include <iostream>
class Singleton {
private:
static Singleton* instance;
Singleton() {}
public:
static Singleton* getInstance() {
if (instance == nullptr) {
instance = new Singleton();
}
return instance;
}
void showMessage() const {
std::cout << "Hello from Singleton!" << std::endl;
}
};
// 初始化静态成员变量
Singleton* Singleton::instance = nullptr;
int main() {
Singleton* s1 = Singleton::getInstance();
Singleton* s2 = Singleton::getInstance();
s1->showMessage();
s2->showMessage();
// 检查是否为同一个实例
std::cout << "Same instance: " << (s1 == s2 ? "Yes" : "No") << std::endl;
return 0;
}
实践中需注意，单例模式在需要全局访问某个资源时非常有用，例如日志记录器、配置管理器等。但需要注意的是，单例模式可能会引入全局状态，从而增加代码的耦合性。
工厂模式用于创建对象，而无需指定具体的类。以下是一个图形类库展示工厂模式的使用：
#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;
}
工厂模式通过将对象的创建逻辑封装在工厂类中，使得代码更加灵活和可扩展。当需要添加新的类时，只需扩展工厂类即可，无需修改客户端代码。
观察者模式用于实现对象之间的依赖关系，当一个对象的状态发生变化时，所有依赖于它的对象都会自动更新。以下是一个消息通知系统的实现：
#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;
}
观察者模式非常适合实现事件驱动的系统，例如 GUI 应用程序中的事件监听机制。通过观察者模式，可以实现低耦合的设计，使得系统的扩展更加灵活。
策略模式用于定义一系列算法，并将它们封装在独立的类中。以下是一个排序算法示例：
#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 Task : 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() {
Task task;
TaskObserver observer1, observer2;
task.attach(&observer1);
task.attach(&observer2);
task.setStatus("RUNNING");
task.setStatus("COMPLETED");
task.detach(&observer1);
task.setStatus("FAILED");
return 0;
}
通过观察者模式，能够灵活地实现任务状态变化的通知机制，而无需在任务类中直接管理观察者。
通过学习，对设计模式有了更深刻的理解，并将其应用到了实际项目中。清晰的讲解和丰富的实战案例让人受益匪浅。在学习过程中，深刻体会到了设计模式的灵活性、代码的可维护性以及面向对象设计原则的重要性。
在未来的学习中，将继续深入学习其他相关课程，进一步提升 C++ 编程能力。相信能够在 C++ 的世界中不断进步，成为一名优秀的开发者。C++ 系列课程不仅掌握了丰富的知识，还学会了如何将这些知识应用到实际项目中。
微信公众号「极客日志」，在微信中扫描左侧二维码关注。展示文案：极客日志 zeeklog
使用加密算法（如AES、TripleDES、Rabbit或RC4）加密和解密文本明文。 在线工具，加密/解密文本在线工具，online
将字符串编码和解码为其 Base64 格式表示形式即可。 在线工具，Base64 字符串编码/解码在线工具，online
将字符串、文件或图像转换为其 Base64 表示形式。 在线工具，Base64 文件转换器在线工具，online
将 Markdown（GFM）转为 HTML 片段，浏览器内 marked 解析；与 HTML 转 Markdown 互为补充。 在线工具，Markdown 转 HTML在线工具，online
将 HTML 片段转为 GitHub Flavored Markdown，支持标题、列表、链接、代码块与表格等；浏览器内处理，可链接预填。 在线工具，HTML 转 Markdown在线工具，online
通过删除不必要的空白来缩小和压缩JSON。 在线工具，JSON 压缩在线工具，online