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 类是一个单例，这意味着应用程序中只有一个数据库实例。这确保了对数据库的访问始终是一致的，并且避免了资源泄漏的风险。
