C++ 设计模式实战案例：面向对象编程的艺术
设计模式是软件工程中的一种重要概念，它描述了在软件设计过程中常见的问题及其解决方案。C++ 作为一种强大的编程语言，广泛应用于系统软件、游戏开发等领域。本文将围绕 C++ 语言，结合实际案例，深入探讨几种经典的设计模式，并展示如何在 C++ 中实现它们。
单例模式（Singleton）
单例模式确保一个类只有一个实例，并提供一个全局访问点。以下是一个使用 C++ 实现的单例模式的示例：
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;
}
在这个例子中，`Singleton` 类通过私有构造函数、拷贝构造函数和赋值运算符来防止外部创建多个实例。`getInstance` 方法用于获取类的唯一实例，而 `releaseInstance` 方法用于释放实例。
工厂模式（Factory Method）
工厂模式定义了一个接口用于创建对象，但让子类决定实例化哪一个类。以下是一个使用 C++ 实现的工厂模式的示例：
cpp
include
include
// 抽象产品
class Product {
public:
virtual void use() = 0;
virtual ~Product() {}
};
// 具体产品A
class ProductA : public Product {
public:
void use() override {
std::cout << "Using Product A..." << std::endl;
}
};
// 具体产品B
class ProductB : public Product {
public:
void use() override {
std::cout << "Using Product B..." << std::endl;
}
};
// 抽象工厂
class Factory {
public:
virtual std::unique_ptr createProduct() = 0;
virtual ~Factory() {}
};
// 具体工厂A
class FactoryA : public Factory {
public:
std::unique_ptr createProduct() override {
return std::make_unique();
}
};
// 具体工厂B
class FactoryB : public Factory {
public:
std::unique_ptr createProduct() override {
return std::make_unique();
}
};
int main() {
FactoryA factoryA;
std::unique_ptr productA = factoryA.createProduct();
productA->use();
FactoryB factoryB;
std::unique_ptr productB = factoryB.createProduct();
productB->use();
return 0;
}
在这个例子中，`Product` 是一个抽象产品，`ProductA` 和 `ProductB` 是具体产品。`Factory` 是一个抽象工厂，`FactoryA` 和 `FactoryB` 是具体工厂。通过工厂方法，客户端代码可以创建具体产品，而不必关心具体产品的创建过程。
观察者模式（Observer）
观察者模式定义了对象之间的一对多依赖关系，当一个对象改变状态时，所有依赖于它的对象都会得到通知并自动更新。以下是一个使用 C++ 实现的观察者模式的示例：
cpp
include
include
include
// 抽象主题
class Subject {
public:
virtual void attach(Observer observer) = 0;
virtual void detach(Observer observer) = 0;
virtual void notify() = 0;
virtual ~Subject() {}
};
// 具体主题
class ConcreteSubject : public Subject {
private:
std::vector observers;
int value;
public:
void attach(Observer observer) override {
observers.push_back(observer);
}
void detach(Observer observer) override {
observers.erase(std::remove(observers.begin(), observers.end(), observer), observers.end());
}
void notify() override {
for (Observer observer : observers) {
observer->update(this);
}
}
void setValue(int value) {
this->value = value;
notify();
}
int getValue() const {
return value;
}
};
// 抽象观察者
class Observer {
public:
virtual void update(Subject subject) = 0;
virtual ~Observer() {}
};
// 具体观察者
class ConcreteObserver : public Observer {
private:
ConcreteSubject subject;
public:
ConcreteObserver(ConcreteSubject subject) : subject(subject) {
subject->attach(this);
}
~ConcreteObserver() {
subject->detach(this);
}
void update(Subject subject) override {
if (subject == this->subject) {
std::cout << "Observer received new value: " <getValue() << std::endl;
}
}
};
int main() {
ConcreteSubject subject;
ConcreteObserver observer(&subject);
subject.setValue(10);
subject.setValue(20);
return 0;
}
在这个例子中，`Subject` 是一个抽象主题，`ConcreteSubject` 是具体主题，`Observer` 是抽象观察者，`ConcreteObserver` 是具体观察者。当主题的值发生变化时，所有注册的观察者都会收到通知并更新自己的状态。
总结
本文通过 C++ 语言，结合实际案例，介绍了单例模式、工厂模式和观察者模式。这些设计模式在软件设计中具有广泛的应用，能够提高代码的可维护性和可扩展性。通过学习和实践这些设计模式，我们可以更好地掌握面向对象编程的艺术。
Comments NOTHING