开闭原则（Open/Closed Principle）指出软件实体（类、模块、函数等）应该对扩展开放，但对修改关闭
组合大于继承
设计模式通常分为三种主要类型：创建型设计模式、结构型设计模式和行为型设计模式
常见的创建型设计模式包括：
单例模式（Singleton）：确保一个类只有一个实例，并提供一个全局访问点来获取这个实例。
用于控制资源的访问，如数据库连接或文件系统。
工厂方法模式（Factory Method）：定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。常用于将对象创建的逻辑从应用逻辑中分离出来。
抽象工厂模式（Abstract Factory）：提供一个接口，用于创建相关的或依赖对象的家族，而不需要明确指定具体类。适用于系统需要处理多系列产品，但希望客户端无需关心具体实现的情况。
建造者模式（Builder）：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。通常用于创建复杂对象，允许用户按步骤指定复杂对象的各个部分，在用户代码中隔离复杂对象的创建和组装过程。
原型模式（Prototype）：用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。
适用于创建重复对象时，效率更高的场景。
常见的结构型设计模式包括：
常见的行为型设计模式包括：
https://zhuanlan.zhihu.com/p/37469260
用法示例：
懒汉版（Lazy Singleton）代码示例
// 单例实例在第一次被使用时才进行初始化
class Singleton
{
private:
static Singleton* instance;
private:
Singleton() {};
~Singleton() {};
Singleton(const Singleton&);
Singleton& operator=(const Singleton&);
public:
static Singleton* getInstance()
{
if(instance == NULL)
instance = new Singleton();
return instance;
}
};
// init static member
Singleton* Singleton::instance = NULL;
Meyers’ Singleton 代码示例
// C++0x之后该实现是线程安全的
class Singleton
{
private:
Singleton() { };
~Singleton() { };
Singleton(const Singleton&);
Singleton& operator=(const Singleton&);
public:
static Singleton& getInstance()
{
static Singleton instance;
return instance;
}
};
饿汉版（Eager Singleton）代码示例
// 单例实例在程序运行时被立即执行初始化
class Singleton
{
private:
static Singleton instance;
private:
Singleton();
~Singleton();
Singleton(const Singleton&);
Singleton& operator=(const Singleton&);
public:
static Singleton& getInstance() {
return instance;
}
}
// initialize defaultly
Singleton Singleton::instance;
用法示例
代码示例
#include 用法示例
代码示例
class OldRectangle {
public:
void draw() {
std::cout << "Old Rectangle draw method." << std::endl;
}
};
class NewShape {
public:
virtual void display() = 0;
virtual ~NewShape() {}
};
// 类适配器
class RectangleAdapter : public NewShape, private OldRectangle {
public:
void display() override {
// 调用 OldRectangle 的 draw 方法
draw();
}
};
// 对象适配器
class RectangleAdapter : public NewShape {
private:
OldRectangle* oldRectangle; // 持有一个对旧接口类的引用
public:
RectangleAdapter(OldRectangle* rectangle) : oldRectangle(rectangle) {}
void display() override {
// 调用 OldRectangle 的 draw 方法
oldRectangle->draw();
}
~RectangleAdapter() {
delete oldRectangle;
}
};
int main() {
OldRectangle* oldRectangle = new OldRectangle();
NewShape* rectangleAdapter = new RectangleAdapter(oldRectangle);
rectangleAdapter->display();
delete rectangleAdapter; // 注意：这将正确地释放适配器和旧的矩形对象
return 0;
}
用法示例
代码示例
class MultimediaSystemFacade {
private:
AudioPlayer audioPlayer;
VideoPlayer videoPlayer;
Broadcaster broadcaster;
public:
void playMultimedia() {
audioPlayer.playAudio();
videoPlayer.playVideo();
}
void sendMessage(const std::string& message) {
broadcaster.broadcastMessage(message);
}
};
用法示例
用法示例
例如：用于不同类型设备（如电视、无线投影仪等）的遥控器应用，每种设备都有不同的实现，但控制接口相似（开/关、调节音量等）
用法示例
用法示例
代码示例
// 抽象类
class Beverage {
public:
// 模板方法，定义算法框架
void prepareRecipe() {
boilWater();
brew(); // 特定于子类的步骤
pourInCup();
addCondiments(); // 特定于子类的步骤
}
protected:
virtual void brew() = 0; // 由子类实现
virtual void addCondiments() = 0;// 由子类实现
void boilWater() {std::cout << "Boiling water" << std::endl;}
void pourInCup() {std::cout << "Pouring into cup" << std::endl;}
virtual ~Beverage() {}
};
// 具体类：咖啡
class Coffee : public Beverage {
protected:
void brew() override {std::cout << "Dripping Coffee through filter" << std::endl;}
void addCondiments() override {std::cout << "Adding Sugar and Milk" << std::endl;}
};
// 具体类：茶
class Tea : public Beverage {
protected:
void brew() override {std::cout << "Steeping the tea" << std::endl;}
void addCondiments() override {std::cout << "Adding Lemon" << std::endl;}
};
用法示例
用法示例
代码示例
// Observer interface
class Observer {
public:
virtual void update(float price) = 0;
virtual ~Observer() {}
};
// Subject interface
class Subject {
public:
virtual void registerObserver(Observer* observer) = 0;
virtual void removeObserver(Observer* observer) = 0;
virtual void notifyObservers() = 0;
virtual ~Subject() {}
};
class Stock : public Subject {
private:
std::list<Observer*> observers;
float price;
public:
// Register an observer
void registerObserver(Observer* observer) override {observers.push_back(observer);}
// Remove an observer
void removeObserver(Observer* observer) override {observers.remove(observer);}
// Notify all registered observers
void notifyObservers() override {
for (auto& observer : observers) {
observer->update(price);
}
}
// Method to update price
void setPrice(float newPrice) {price = newPrice; notifyObservers();}
};
class PriceDisplay : public Observer {
private:
float price;
public:
void update(float newPrice) override {price = newPrice; display();}
void display() const {std::cout << "Current Stock Price: $" << price << std::endl;}
};
int main() {
Stock stock; // Create a Stock object which is the subject.
PriceDisplay display; // Create an observer.
stock.registerObserver(&display); // Register the observer with the subject.
stock.setPrice(150.0f); // Change the stock price, triggers notifications.
stock.setPrice(155.5f); // Change the stock price again.
stock.removeObserver(&display); // Unregister the observer.
stock.setPrice(160.0f); // No notification this time.
return 0;
}
用法示例
代码示例
#include