侯捷 C++ 课程学习笔记：设计模式在面向对象开发中的应用

Ne0inhk

23 Mar 2026 — 10 min read

在侯捷老师的《C++ 面向对象开发》课程中，除了对面向对象编程的基础特性（封装、继承和多态）的深入讲解外，还引入了设计模式这一高级主题。设计模式是面向对象编程中的一种最佳实践，能够帮助开发者解决常见的设计问题，提升代码的可维护性和可扩展性。侯捷老师通过丰富的实战案例，让我对设计模式在 C++ 开发中的应用有了更深刻的理解。以下是我对这部分内容的学习笔记和心得体会。

一、课程核心内容：设计模式在 C++ 面向对象开发中的应用

侯捷老师在课程中详细讲解了几种常用的设计模式，包括单例模式（Singleton）、工厂模式（Factory）、观察者模式（Observer）和策略模式（Strategy）。这些设计模式不仅解决了实际开发中的常见问题，还通过面向对象的思想提升了代码的可扩展性和可维护性。

（一）单例模式（Singleton）

单例模式是设计模式中最简单的一种，它确保一个类只有一个实例，并提供一个全局访问点。侯捷老师通过以下代码展示了单例模式的实现：

#include<iostream>classSingleton{private:static Singleton* instance;Singleton(){}// 私有构造函数public:static Singleton*getInstance(){if(instance ==nullptr){ instance =newSingleton();}return instance;}voidshowMessage()const{ std::cout <<"Hello from Singleton!"<< std::endl;}};// 初始化静态成员变量 Singleton* Singleton::instance =nullptr;intmain(){ Singleton* s1 =Singleton::getInstance(); Singleton* s2 =Singleton::getInstance(); s1->showMessage(); s2->showMessage();// 检查是否为同一个实例 std::cout <<"Same instance: "<<(s1 == s2 ?"Yes":"No")<< std::endl;return0;}

侯捷老师指出，单例模式在需要全局访问某个资源时非常有用，例如日志记录器、配置管理器等。但需要注意的是，单例模式可能会引入全局状态，从而增加代码的耦合性。

（二）工厂模式（Factory）

工厂模式用于创建对象，而无需指定具体的类。侯捷老师通过一个简单的图形类库展示了工厂模式的使用：

#include<iostream>#include<memory>#include<string>// 基类classShape{public:virtualvoiddraw()const=0;virtual~Shape()=default;};// 具体类classCircle:publicShape{public:voiddraw()constoverride{ std::cout <<"Drawing a Circle"<< std::endl;}};classRectangle:publicShape{public:voiddraw()constoverride{ std::cout <<"Drawing a Rectangle"<< std::endl;}};// 工厂类classShapeFactory{public: std::unique_ptr<Shape>getShape(const std::string& shapeType){if(shapeType =="CIRCLE"){return std::make_unique<Circle>();}elseif(shapeType =="RECTANGLE"){return std::make_unique<Rectangle>();}returnnullptr;}};intmain(){ ShapeFactory shapeFactory;auto shape1 = shapeFactory.getShape("CIRCLE"); shape1->draw();auto shape2 = shapeFactory.getShape("RECTANGLE"); shape2->draw();return0;}

侯捷老师强调，工厂模式通过将对象的创建逻辑封装在工厂类中，使得代码更加灵活和可扩展。当需要添加新的类时，只需扩展工厂类即可，无需修改客户端代码。

（三）观察者模式（Observer）

观察者模式用于实现对象之间的依赖关系，当一个对象的状态发生变化时，所有依赖于它的对象都会自动更新。侯捷老师通过一个简单的消息通知系统展示了观察者模式的实现：

#include<iostream>#include<vector>#include<string>// 抽象观察者classObserver{public:virtualvoidupdate(const std::string& message)=0;virtual~Observer()=default;};// 抽象主题classSubject{private: std::vector<Observer*> observers;public:voidattach(Observer* observer){ observers.push_back(observer);}voiddetach(Observer* observer){ observers.erase(std::remove(observers.begin(), observers.end(), observer), observers.end());}voidnotify(const std::string& message){for(auto observer : observers){ observer->update(message);}}};// 具体观察者classConcreteObserver:publicObserver{public:voidupdate(const std::string& message)override{ std::cout <<"Observer received message: "<< message << std::endl;}};intmain(){ Subject subject; ConcreteObserver observer1, observer2; subject.attach(&observer1); subject.attach(&observer2); subject.notify("Hello Observers!"); subject.detach(&observer1); subject.notify("Observer1 detached.");return0;}

侯捷老师指出，观察者模式非常适合实现事件驱动的系统，例如 GUI 应用程序中的事件监听机制。通过观察者模式，可以实现低耦合的设计，使得系统的扩展更加灵活。

（四）策略模式（Strategy）

策略模式用于定义一系列算法，并将它们封装在独立的类中。侯捷老师通过一个简单的排序算法示例展示了策略模式的使用：

#include<iostream>#include<vector>#include<algorithm>// 抽象策略classSortStrategy{public:virtualvoidsort(std::vector<int>& data)const=0;virtual~SortStrategy()=default;};// 具体策略：冒泡排序classBubbleSort:publicSortStrategy{public:voidsort(std::vector<int>& data)constoverride{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]);}}}}};// 具体策略：快速排序classQuickSort:publicSortStrategy{public:voidsort(std::vector<int>& data)constoverride{ std::sort(data.begin(), data.end());}};// 上下文类classSorter{private: SortStrategy* strategy;public:Sorter(SortStrategy* strategy):strategy(strategy){}voidsetStrategy(SortStrategy* strategy){this->strategy = strategy;}voidsort(std::vector<int>& data){ strategy->sort(data);}};intmain(){ std::vector<int> data ={5,2,9,1,5,6}; Sorter sorter(newBubbleSort()); sorter.sort(data); std::cout <<"Sorted data (Bubble Sort): ";for(int num : data){ std::cout << num <<" ";} std::cout << std::endl; sorter.setStrategy(newQuickSort()); sorter.sort(data); std::cout <<"Sorted data (Quick Sort): ";for(int num : data){ std::cout << num <<" ";} std::cout << std::endl;return0;}

侯捷老师强调，策略模式通过将算法封装在独立的类中，使得算法可以独立于客户端代码进行扩展和修改。这种方式不仅提高了代码的可维护性，还使得算法的切换更加灵活。

二、学习心得：设计模式在实际开发中的价值

通过学习侯捷老师的《C++ 面向对象开发》课程，我对设计模式有了更深刻的理解。侯捷老师不仅讲解了设计模式的理论知识，还通过大量实战案例展示了如何在实际开发中应用这些模式。

（一）设计模式的灵活性

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

（二）提升代码的可维护性

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

（三）面向对象设计原则的应用

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

三、实际应用案例：设计模式在项目中的实战应用

在学习侯捷老师的课程后，我将所学知识应用到了实际项目中。我们团队负责开发一个简单的任务调度系统，需要管理任务的创建、执行和通知机制。通过侯捷老师对设计模式的讲解，我决定使用工厂模式和观察者模式来实现这一功能。

（一）项目背景

任务调度系统需要管理任务的创建、执行和通知机制。每个任务可以被分配到不同的执行器上，并且需要在任务状态发生变化时通知相关观察者。系统需要支持灵活的任务扩展和通知机制。

（二）工厂模式的应用

我们使用工厂模式来创建任务对象。任务对象的类型可以根据任务的类型动态决定。以下是代码示例：

#include<iostream>#include<memory>#include<string>// 基类classTask{public:virtualvoidexecute()const=0;virtual~Task()=default;};// 具体任务classEmailTask:publicTask{public:voidexecute()constoverride{ std::cout <<"Sending email..."<< std::endl;}};classFileTask:publicTask{public:voidexecute()constoverride{ std::cout <<"Processing file..."<< std::endl;}};// 工厂类classTaskFactory{public: std::unique_ptr<Task>createTask(const std::string& taskType){if(taskType =="EMAIL"){return std::make_unique<EmailTask>();}elseif(taskType =="FILE"){return std::make_unique<FileTask>();}returnnullptr;}};intmain(){ TaskFactory taskFactory;auto task1 = taskFactory.createTask("EMAIL"); task1->execute();auto task2 = taskFactory.createTask("FILE"); task2->execute();return0;}

通过工厂模式，我们能够灵活地创建不同类型的任务对象，而无需在客户端代码中直接实例化具体类。

（三）观察者模式的应用

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

#include<iostream>#include<vector>#include<string>// 抽象观察者classObserver{public:virtualvoidupdate(const std::string& message)=0;virtual~Observer()=default;};// 抽象主题classSubject{private: std::vector<Observer*> observers;public:voidattach(Observer* observer){ observers.push_back(observer);}voiddetach(Observer* observer){ observers.erase(std::remove(observers.begin(), observers.end(), observer), observers.end());}voidnotify(const std::string& message){for(auto observer : observers){ observer->update(message);}}};// 具体主题：任务classTask:publicSubject{private: std::string status;public:voidsetStatus(const std::string& newStatus){ status = newStatus;notify("Task status changed to: "+ status);}};// 具体观察者classTaskObserver:publicObserver{public:voidupdate(const std::string& message)override{ std::cout <<"Observer received message: "<< message << std::endl;}};intmain(){ Task task; TaskObserver observer1, observer2; task.attach(&observer1); task.attach(&observer2); task.setStatus("RUNNING"); task.setStatus("COMPLETED"); task.detach(&observer1); task.setStatus("FAILED");return0;}

通过观察者模式，我们能够灵活地实现任务状态变化的通知机制，而无需在任务类中直接管理观察者。

四、总结与展望

通过学习侯捷老师的《C++ 面向对象开发》课程，我对设计模式有了更深刻的理解，并将其应用到了实际项目中。侯捷老师清晰的讲解和丰富的实战案例让我受益匪浅。在学习过程中，我深刻体会到了设计模式的灵活性、代码的可维护性以及面向对象设计原则的重要性。
在未来的学习中，我将继续深入学习侯捷老师的其他课程，如《C++ STL 标准库与泛型编程》和《C++ 新标准 11/14》，进一步提升自己的 C++ 编程能力。我相信，在侯捷老师的指导下，我能够在 C++ 的世界中不断进步，成为一名优秀的开发者。
侯捷老师的 C++ 系列课程不仅让我掌握了丰富的知识，还让我学会了如何将这些知识应用到实际项目中。感谢侯捷老师的辛勤付出，让我在 C++ 的学习道路上找到了方向。