C++编程秘籍:深度解析单例、工厂、观察者与策略模式实战代码解析

引言
在C++编程中,设计模式是一种强大的工具,可以帮助开发者解决常见的问题,提高代码的可维护性和可扩展性。本文将深入解析四种经典的设计模式:单例、工厂、观察者与策略模式,并通过实战代码进行详细解析。
单例模式
单例模式确保一个类只有一个实例,并提供一个全局访问点。以下是一个单例模式的实现示例:
#include

class Singleton {
private:
static Singleton* instance;
Singleton() {}
Singleton(const Singleton&) = delete;
Singleton& operator=(const Singleton&) = delete;

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

void doSomething() {
std::cout << "Doing something..." << std::endl; } ~Singleton() { delete instance; instance = nullptr; } }; Singleton* Singleton::instance = nullptr; int main() { Singleton* s1 = Singleton::getInstance(); Singleton* s2 = Singleton::getInstance(); if (s1 == s2) { std::cout << "Both instances are the same." << std::endl; } s1->doSomething();

return 0;
}
工厂模式
工厂模式定义了一个接口,用于创建对象,但让子类决定实例化哪一个类。以下是一个工厂模式的实现示例:
#include
#include

class ProductA {
public:
void use() {
std::cout << "Using Product A..." << std::endl; } }; class ProductB { public: void use() { std::cout << "Using Product B..." << std::endl; } }; class Factory { public: std::shared_ptr createProduct(int type) {
if (type == 1) {
return std::make_shared();
} else if (type == 2) {
return std::make_shared();
}
return nullptr;
}
};

int main() {
Factory factory;
auto product = factory.createProduct(1);
if (product) {
product->use();
}

return 0;
}
观察者模式
观察者模式定义了一种一对多的依赖关系,当一个对象的状态发生变化时,所有依赖于它的对象都会得到通知并自动更新。以下是一个观察者模式的实现示例:
#include
#include
#include

class Subject {
private:
std::vector> observers;

public:
void addObserver(std::function observer) {
observers.push_back(observer);
}

void notify() {
for (auto& observer : observers) {
observer();
}
}
};

class Observer {
public:
virtual void update() = 0;
};

class ConcreteObserverA : public Observer {
public:
void update() override {
std::cout << "Observer A notified..." << std::endl; } }; class ConcreteObserverB : public Observer { public: void update() override { std::cout << "Observer B notified..." << std::endl; } }; int main() { Subject subject; ConcreteObserverA observerA; ConcreteObserverB observerB; subject.addObserver(std::bind(&Observer::update, &observerA)); subject.addObserver(std::bind(&Observer::update, &observerB)); subject.notify(); return 0; } 策略模式 策略模式定义了一系列算法,将每一个算法封装起来,并使它们可以互相替换。以下是一个策略模式的实现示例: #include
#include

class Strategy {
public:
virtual void execute() = 0;
virtual ~Strategy() {}
};

class ConcreteStrategyA : public Strategy {
public:
void execute() override {
std::cout << "Executing strategy A..." << std::endl; } }; class ConcreteStrategyB : public Strategy { public: void execute() override { std::cout << "Executing strategy B..." << std::endl; } }; class Context { private: std::unique_ptr strategy;

public:
void setStrategy(std::unique_ptr strategy) {
this->strategy = std::move(strategy);
}

void executeStrategy() {
if (strategy) {
strategy->execute();
}
}
};

int main() {
Context context;
context.setStrategy(std::make_unique());
context.executeStrategy();

context.setStrategy(std::make_unique());
context.executeStrategy();

return 0;
}
总结
本文深入解析了单例、工厂、观察者与策略模式,并通过实战代码展示了如何在实际项目中应用这些设计模式。掌握这些设计模式将有助于提高C++代码的质量和可维护性。