C++ 设计模式实现精讲
设计模式是软件工程中的一种重要概念，它提供了一系列可重用的解决方案，用于解决在软件设计过程中遇到的问题。C++ 作为一种强大的编程语言，支持多种设计模式。本文将围绕 C++ 语言，对几种常见的设计模式进行实现和讲解。
1. 单例模式（Singleton）
单例模式确保一个类只有一个实例，并提供一个全局访问点。以下是一个简单的单例模式实现：
cpp
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;
}
static void releaseInstance() {
if (instance != nullptr) {
delete instance;
instance = nullptr;
}
}
};
Singleton Singleton::instance = nullptr;
int main() {
Singleton s1 = Singleton::getInstance();
Singleton s2 = Singleton::getInstance();
std::cout << "s1 and s2 are the same instance: " << (s1 == s2) <doSomething();
Singleton::releaseInstance();
return 0;
}
2. 工厂模式（Factory Method）
工厂模式定义了一个接口，用于创建对象，但让子类决定实例化哪一个类。以下是一个工厂模式的实现：
cpp
include
include
class Product {
public:
virtual void use() = 0;
virtual ~Product() {}
};
class ConcreteProductA : public Product {
public:
void use() override {
std::cout << "Using ConcreteProductA" << std::endl;
}
};
class ConcreteProductB : public Product {
public:
void use() override {
std::cout << "Using ConcreteProductB" << std::endl;
}
};
class Creator {
public:
virtual std::unique_ptr createProduct() = 0;
virtual ~Creator() {}
};
class ConcreteCreatorA : public Creator {
public:
std::unique_ptr createProduct() override {
return std::make_unique();
}
};
class ConcreteCreatorB : public Creator {
public:
std::unique_ptr createProduct() override {
return std::make_unique();
}
};
int main() {
Creator creatorA = new ConcreteCreatorA();
Creator creatorB = new ConcreteCreatorB();
std::unique_ptr productA = creatorA->createProduct();
std::unique_ptr productB = creatorB->createProduct();
productA->use();
productB->use();
delete creatorA;
delete creatorB;
return 0;
}
3. 观察者模式（Observer）
观察者模式定义了一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并自动更新。以下是一个观察者模式的实现：
cpp
include
include
include
class Observer {
public:
virtual void update() = 0;
virtual ~Observer() {}
};
class ConcreteObserverA : public Observer {
public:
void update() override {
std::cout << "Observer A updated" << std::endl;
}
};
class ConcreteObserverB : public Observer {
public:
void update() override {
std::cout << "Observer B updated" << std::endl;
}
};
class Subject {
private:
std::vector 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() {
for (Observer observer : observers) {
observer->update();
}
}
};
int main() {
Subject subject;
Observer observerA = new ConcreteObserverA();
Observer observerB = new ConcreteObserverB();
subject.attach(observerA);
subject.attach(observerB);
subject.notify(); // Observer A updated, Observer B updated
subject.detach(observerA);
subject.notify(); // Observer B updated
delete observerA;
delete observerB;
return 0;
}
4. 装饰者模式（Decorator）
装饰者模式动态地给一个对象添加一些额外的职责，而不改变其接口。以下是一个装饰者模式的实现：
cpp
include
include
class Component {
public:
virtual void operation() = 0;
virtual ~Component() {}
};
class ConcreteComponent : public Component {
public:
void operation() override {
std::cout << "ConcreteComponent operation" <operation();
}
};
class ConcreteDecoratorA : public Decorator {
public:
ConcreteDecoratorA(Component c) : Decorator(c) {}
void operation() override {
Decorator::operation();
addBehavior();
}
void addBehavior() {
std::cout << "ConcreteDecoratorA added behavior" <operation(); // ConcreteComponent operation, ConcreteDecoratorA added behavior
delete decoratedComponent;
delete component;
return 0;
}
总结
本文通过 C++ 语言实现了几种常见的设计模式，包括单例模式、工厂模式、观察者模式和装饰者模式。这些设计模式在软件设计中具有广泛的应用，能够提高代码的可维护性和可扩展性。在实际开发中，合理运用设计模式能够帮助我们更好地解决软件设计中的问题。
Comments NOTHING