【C++】设计模式

**C++ 设计模式**

设计模式是一套被反复使用、多数已被 Formalize 的对特定实现问题的解决方案。它提供了一种模板或框架，让我们可以更好地理解和应用这些解决方案。

在本文中，我们将讨论 C++ 中常见的设计模式，包括单例模式、工厂模式、观察者模式、策略模式等。

###1. 单例模式**定义**: 单例模式是一种创建型模式，它保证一个类只有一个实例，并提供全局访问点。

**示例代码**:

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

private:
 Singleton() {}
 ~Singleton() {}

 static Singleton* instance;
};

Singleton* Singleton::instance = nullptr;

int main() {
 Singleton* singleton1 = Singleton::getInstance();
 Singleton* singleton2 = Singleton::getInstance();

 // singleton1 和 singleton2 指向同一个对象 if (singleton1 == singleton2) {
 std::cout << "Singleton pattern works!" << std::endl;
 }

 return0;
}

**注释**: 在上面的示例中，我们使用了一个静态变量 `instance` 来存储 Singleton 的实例。每次调用 `getInstance()` 方法时，会检查 `instance` 是否为 nullptr，如果是，则创建一个新的 Singleton 实例并赋值给 `instance`。

###2. 工厂模式**定义**: 工厂模式是一种创建型模式，它提供了创建对象的接口，而不需要暴露具体的实现类。

**示例代码**:

cppclass Animal {
public:
 virtual void sound() =0;
};

class Dog : public Animal {
public:
 void sound() override {
 std::cout << "Woof!" << std::endl;
 }
};

class Cat : public Animal {
public:
 void sound() override {
 std::cout << "Meow!" << std::endl;
 }
};

class AnimalFactory {
public:
 static Animal* createAnimal(const std::string& type) {
 if (type == "dog") {
 return new Dog();
 } else if (type == "cat") {
 return new Cat();
 } else {
 return nullptr;
 }
 }
};

int main() {
 Animal* animal = AnimalFactory::createAnimal("dog");
 animal->sound(); // Woof!

 animal = AnimalFactory::createAnimal("cat");
 animal->sound(); // Meow!

 return0;
}

**注释**: 在上面的示例中，我们定义了一个 `Animal` 接口和两个具体的实现类 `Dog` 和 `Cat`。我们还定义了一个 `AnimalFactory` 类，提供了创建对象的接口。通过使用工厂模式，我们可以在不暴露具体实现类的情况下创建对象。

###3. 观察者模式**定义**: 观察者模式是一种行为型模式，它允许一个对象（被观察者）将其状态改变通知给其他对象（观察者）。

**示例代码**:

cppclass Subject {
public:
 void attach(Observer* observer) {
 observers.push_back(observer);
 }

 void detach(Observer* observer) {
 observers.remove(observer);
 }

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

private:
 std::vector observers;
};

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

class ConcreteObserver : public Observer {
public:
 void update() override {
 std::cout << "Received notification!" << std::endl;
 }
};

int main() {
 Subject subject;
 ConcreteObserver observer;

 subject.attach(&observer);
 subject.notify(); // Received notification!

 return0;
}

**注释**: 在上面的示例中，我们定义了一个 `Subject` 类和一个 `Observer` 接口。我们还定义了一个具体的实现类 `ConcreteObserver`。通过使用观察者模式，我们可以在被观察者改变状态时通知给其他对象。

###4. 策略模式**定义**: 策略模式是一种行为型模式，它允许一个算法或策略在不同的上下文中使用。

**示例代码**:

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

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 {
public:
 void setStrategy(Strategy* strategy) {
 this->strategy = strategy;
 }

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

private:
 Strategy* strategy;
};

int main() {
 Context context;

 ConcreteStrategyA strategyA;
 context.setStrategy(&strategyA);
 context.execute(); // Executing strategy A!

 ConcreteStrategyB strategyB;
 context.setStrategy(&strategyB);
 context.execute(); // Executing strategy B!

 return0;
}

**注释**: 在上面的示例中，我们定义了一个 `Strategy` 接口和两个具体的实现类 `ConcreteStrategyA` 和 `ConcreteStrategyB`。我们还定义了一个 `Context` 类，提供了设置策略和执行策略的接口。通过使用策略模式，我们可以在不同的上下文中使用相同的算法或策略。

以上就是 C++ 中常见的设计模式的介绍。这些模式可以帮助你更好地理解和应用软件设计原则，使你的代码更加模块化、可维护性强、易于扩展等优点。