c++++ 框架中广泛应用设计模式，包括单例模式、工厂模式、抽象工厂模式、建造者模式和适配器模式。这些模式提高了代码的可读性、可维护性和可扩展性。例如，单例模式确保仅存在一个实例，工厂模式分离了对象的创建，抽象工厂模式分解了工厂创建过程，建造者模式分步构建复杂对象，适配器模式使不兼容的类协同工作。实战案例演示了单例模式在数据库连接中的应用。

C++ 框架中的设计模式集萃：全面的运用指南

引言

设计模式是软件开发中的可重用解决方案，用于解决常见编程问题。在 C++ 框架中，设计模式被广泛使用，以提高代码的可读性、可维护性和可扩展性。本文将提供 C++ 框架中常用的设计模式的全面指南，并通过实战案例演示它们的应用。

立即学习“C++免费学习笔记（深入）”；

单例模式

单例模式确保一个类只有一个实例，并提供全局访问该实例的接口。

代码实现：

class Singleton {
private:
    Singleton() {}
    static Singleton* instance;

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

    void someMethod() {
        // ...
    }
};

// 在全局范围内初始化单例
Singleton* Singleton::instance = nullptr;

工厂模式

工厂模式通过创建类实例的高级接口，将对象的创建与业务逻辑分离。

代码实现：

class Factory {
public:
    static Pizza* createPizza(const std::string& type) {
        if (type == "cheese") {
            return new CheesePizza();
        } else if (type == "veggie") {
            return new VeggiePizza();
        } else {
            return nullptr;
        }
    }
};

class Pizza {
public:
    virtual void prepare() = 0;
    virtual void bake() = 0;
    virtual void cut() = 0;
    virtual void box() = 0;
};

抽象工厂模式

抽象工厂模式通过创建一组相关产品的工厂接口，将一个工厂创建过程分解为多个更细粒度的子工厂。

代码实现：

class PizzaFactory {
public:
    virtual Pizza* createPizza(const std::string& type) = 0;
};

class NYPizzaFactory : public PizzaFactory {
public:
    Pizza* createPizza(const std::string& type) override {
        if (type == "cheese") {
            return new NYCheesePizza();
        } else if (type == "veggie") {
            return new NYVeggiePizza();
        } else {
            return nullptr;
        }
    }
};

建造者模式

建造者模式将一个复杂对象的构建分成多个独立的步骤，并封装每个构建步骤的具体实现。

代码实现：

class PizzaBuilder {
public:
    virtual void buildDough() = 0;
    virtual void buildSauce() = 0;
    virtual void buildTopping() = 0;
    virtual void buildCheese() = 0;
    virtual Pizza* getPizza() = 0;
};

class ConcretePizzaBuilder : public PizzaBuilder {
public:
    Pizza* pizza;

    ConcretePizzaBuilder() {
        pizza = new Pizza();
    }

    void buildDough() override {
        // ...
    }

    void buildSauce() override {
        // ...
    }

    void buildTopping() override {
        // ...
    }

    void buildCheese() override {
        // ...
    }

    Pizza* getPizza() override {
        return pizza;
    }
};

适配器模式

适配器模式使不兼容的类能够协同工作，通过创建一个包装类来转换一个类与另一个类的接口。

代码实现：

class Target {
public:
    virtual void request() = 0;
};

class Adaptee {
public:
    void specificRequest() {
        // ...
    }
};

class Adapter : public Target {
private:
    Adaptee* adaptee;

public:
    Adapter(Adaptee* adaptee) : adaptee(adaptee) {}

    void request() override {
        adaptee->specificRequest();
    }
};

实战案例

以下是一个演示单例模式在真实世界中的应用的示例：

class Database {
private:
    Database() {}
    static Database* instance;

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

    void connect() {
        // 连接到数据库
    }
};

// 在程序启动时初始化单例
Database* Database::instance = getInstance();

在这个例子中，Database 类是一个单例，这意味着应用程序中只有一个数据库实例。这确保了对数据库的访问始终是一致的，并且避免了资源泄漏的风险。