C++设计模式实战攻略

# 1. 设计模式概述与C++实现基础

## 1.1 设计模式的基本概念
设计模式是软件工程中，针对特定问题的可复用解决方案。它们是前人智慧的结晶，通过提供一套共通的设计模板，帮助开发者避免重复造轮子，提高开发效率和系统的可维护性。

## 1.2 设计模式的分类
设计模式主要分为三类：创建型模式、结构型模式和行为型模式。创建型模式关注对象创建，结构型模式关注类和对象的结构组合，而行为型模式关注对象间的通信。

## 1.3 C++实现设计模式的基础
C++作为一种支持面向对象编程的语言，具有类、继承、多态等特性，为实现各种设计模式提供了坚实的基础。理解C++语言特性是深入学习设计模式的前提。

为了进一步理解设计模式，让我们从C++语言的特性开始学习，并探讨如何在C++中实现这些设计模式。每一种设计模式背后都有其适用的场景和解决的问题，我们将一一展开讨论，并通过示例代码加深理解。

# 2. 创建型模式在C++中的应用

### 2.1 单例模式的实现和应用场景

#### 2.1.1 单例模式的基本原理
单例模式是创建型设计模式之一，它确保一个类只有一个实例，并提供一个全局访问点来获取这个实例。在C++中，单例模式的实现涉及私有构造函数、一个私有静态变量以及一个公有静态方法来获取实例。

class Singleton {
private:
    static Singleton* instance;
    Singleton() {} // 私有构造函数

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

单例模式的核心概念是控制实例的创建过程，确保全局只有一个实例被创建。这通常用于管理资源，比如数据库连接、系统日志实例等，避免创建多个实例导致资源浪费或不一致状态。

#### 2.1.2 线程安全的单例实现
在多线程环境下，单例模式的实现需要考虑线程安全。一个常见的线程安全的单例模式实现方式是使用双重检查锁定（Double-Checked Locking）。

class Singleton {
private:
    static Singleton* instance;
    static std::mutex mtx;
    Singleton() {} // 私有构造函数

public:
    static Singleton* getInstance() {
        if (instance == nullptr) {
            std::lock_guard<std::mutex> lock(mtx); // 锁定
            if (instance == nullptr) {
                instance = new Singleton();
            }
        }
        return instance;
    }
};

双重检查锁定中，我们首先检查实例是否已经创建，如果没有，则加锁并再次检查。这样做减少了锁的开销，因为锁只在实例未创建时才会获取，提高了效率。需要注意的是，双重检查锁定模式在C++11之前并不是完全线程安全的，因为C++11之前编译器对于内存模型的处理不支持，所以需要使用特定编译器的原子操作保证其线程安全性。

### 2.2 工厂方法模式与抽象工厂模式

#### 2.2.1 工厂方法的定义及C++实现
工厂方法模式定义了一个创建对象的接口，但让子类决定实例化哪一个类。工厂方法让类的实例化推迟到子类中进行。

class Product {};
class ConcreteProduct : public Product {};

class Creator {
public:
    virtual Product* factoryMethod() = 0;
    Product* someOperation() {
        Product* product = factoryMethod();
        // 使用product执行一些操作...
        return product;
    }
};

class ConcreteCreator : public Creator {
public:
    Product* factoryMethod() {
        return new ConcreteProduct();
    }
};

工厂方法模式的核心在于通过子类来决定要创建的具体产品类型。这种模式常用于创建对象时，其类型需要根据运行时的条件来决定。

#### 2.2.2 抽象工厂模式的引入和优势
抽象工厂模式提供了一种方式，可以创建一系列相关或相互依赖的对象，而无需指定它们具体的类。

class AbstractFactory {
public:
    virtual AbstractProductA* createProductA() = 0;
    virtual AbstractProductB* createProductB() = 0;
};

class ConcreteFactory1 : public AbstractFactory {
public:
    AbstractProductA* createProductA() override {
        return new ProductA1();
    }
    AbstractProductB* createProductB() override {
        return new ProductB1();
    }
};

class AbstractProductA {};
class AbstractProductB {};

class ProductA1 : public AbstractProductA {};
class ProductB1 : public AbstractProductB {};
// ... 其他产品类的定义

抽象工厂模式适合用于产品族的创建，这样可以确保系统中的一致性。它允许用户在不直接指定具体产品类的情况下创建多个产品的实例，这些产品是相互关联的。抽象工厂模式主要优点是分离了具体的类，并且对产品类簇的扩展提供了支持。缺点是增加了系统的复杂度，且难以支持新种类的产品，因为扩展需要修改抽象工厂接口。

### 2.3 建造者模式的灵活运用

#### 2.3.1 建造者模式解决复杂对象构建问题
建造者模式是一种创建型设计模式，它提供了一种创建对象的最佳方式。一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

class Product {
public:
    void addPart(const std::string& part) {
        // 添加部件逻辑...
    }
};

class Builder {
public:
    virtual void buildPartA() = 0;
    virtual void buildPartB() = 0;
    virtual Product* getResult() = 0;
};

class ConcreteBuilder : public Builder {
private:
    Product* product;

public:
    ConcreteBuilder() : product(new Product()) {}
    void buildPartA() override {
        // 实现部件A的构建逻辑...
        product->addPart("部件A");
    }
    void buildPartB() override {
        // 实现部件B的构建逻辑...
        product->addPart("部件B");
    }
    Product* getResult() override {
        return product;
    }
};

建造者模式适用的场景包括创建复杂对象，比如对象的创建过程需要多个步骤，而且这些步骤相互依赖，或者需要构造的产品对象有不同的表示但使用相同的构建过程。建造者模式的主要优点是封装性好，创建复杂对象的算法可以独立于该对象的组成部分以及它们的装配方式。

#### 2.3.2 C++中实现建造者模式的注意事项
在C++中实现建造者模式时，需要注意以下几点：

- 保持接口简洁：建造者模式的接口需要足够简单，仅需提供构建和获取最终产品的接口。
- 定义可选的构造步骤：为了适应不同的使用场景，应该允许建造者中包含可选的构造步骤。
- 考虑资源管理：如果构建步骤涉及到资源的分配，应该在合适的时候进行资源的释放，比如使用智能指针管理动态分配的内存。

通过这些注意事项的遵循，建造者模式在C++中的实现会更加健壮，能够应对更多的构建场景，提高代码的可维护性和可扩展性。

# 3. 结构型模式在C++中的实践

在软件开发中，结构型模式关注如何组合类和对象以获得更大的结构。通过使用这些模式，我们可以创建出更加灵活和可维护的代码结构。本章节将详细介绍几种在C++中常见的结构型设计模式，并展示它们的实践技巧。

## 3.1 适配器模式的多种实现方式

适配器模式是结构型设计模式之一，它能够将一个类的接口转换成客户期望的另一个接口。这种模式使得原本接口不兼容的类可以一起工作。

### 3.1.1 适配器模式的结构和作用

适配器模式包含三类主要角色：

- **目标（Target）接口**：定义客户所期望的接口。
- **适配器（Adapter）类**：将源接口转换为特定目标接口。
- **源（Adaptee）类**：包含一些有用的操作，但接口与目标接口不一致。

适配器模式的作用在于解决接口不兼容问题，让不兼容的类可以协同工作。

### 3.1.2 C++中的类适配器与对象适配器

在C++中，适配器模式可以通过两种方式实现：类适配器模式和对象适配器模式。

#### 类适配器模式

类适配器模式通过多重继承实现适配器。以下是一个简单的类适配器模式示例：

// 源类
class Adaptee {
public:
    void specificOperation() {
        std::cout << "Adaptee specific operation." << std::endl;
    }
};

// 目标接口
class Target {
public:
    virtual void request() = 0;
    virtual ~Target() {}
};

// 类适配器
class Adapter : public Target, public Adaptee {
public:
    void request() override {
        // 在这里转换Adaptee的接口到Target的接口
        std::cout << "Adapter request." << std::endl;
        specificOperation();
    }
};

int main() {
    Adapter a;
    a.request();
    return 0;
}

在代码示例中，