C++设计模式的创建型模式可以分为单例模型、简单工厂模式、工厂方法模式、抽象工厂模式、原型模式、建造者模式。
1、单例模式(Singleton Pattern):保证一个类只有一个实例,并提供一个访问它的全局访问点。例如,在一个多线程程序中,使用单例模式可以确保只有一个线程访问某个资源。
class Singleton {
private:
static Singleton* instance;
// 私有构造函数,防止外部创建实例
Singleton() {}
public:
// 获取单例实例的静态方法
static Singleton* getInstance() {
if (instance == nullptr) {
instance = new Singleton();
}
return instance;
}
// 其他成员函数
void doSomething() {
// 实现单例类的功能
}
};
// 初始化静态成员变量
Singleton* Singleton::instance = nullptr;
// 在需要使用单例的地方调用getInstance()方法获取实例
Singleton* singleton = Singleton::getInstance();
singleton->doSomething();
2、简单工厂模式:
以下代码实现了简单工厂模式,其中包含三个类:抽象产品类 Product、具体产品类 ProductA 和 ProductB,以及工厂类 Factory。
在工厂类中,通过 createProduct 方法根据传入的参数类型创建对应的产品对象。而在客户端代码中,只需要调用工厂类的 createProduct 方法即可得到所需的产品对象,无需关心具体的产品创建过程。
这种方式可以方便地扩展新的产品类,同时也避免了客户端代码与具体产品类之间的耦合。但是也有一定的缺点,例如增加新的产品需要修改工厂类的代码,而且如果产品种类过多,工厂类也会变得臃肿。
#include <iostream>
#include <string>
using namespace std;
// 定义抽象产品类
class Product {
public:
virtual void use() = 0;
};
// 定义具体产品类 A
class ProductA : public Product {
public:
void use() override {
cout << "使用产品 A" << endl;
}
};
// 定义具体产品类 B
class ProductB : public Product {
public:
void use() override {
cout << "使用产品 B" << endl;
}
};
// 定义工厂类
class Factory {
public:
static Product* createProduct(char type) {
Product* product = nullptr;
switch (type) {
case 'A':
product = new ProductA();
break;
case 'B':
product = new ProductB();
break;
default:
break;
}
return product;
}
};
int main() {
// 创建产品 A
Product* productA = Factory::createProduct('A');
productA->use();
// 创建产品 B
Product* productB = Factory::createProduct('B');
productB->use();
// 释放内存
delete productA;
delete productB;
return 0;
}
3、工厂方法模式(Factory Method Pattern):定义一个用于创建对象的接口,让子类决定实例化哪一个类。例如,一个汽车制造厂可以定义一个工厂接口,让不同的子类工厂来创建不同型号的汽车。
#include <iostream>
#include <string>
using namespace std;
// 定义抽象产品类
class Product {
public:
virtual void use() = 0;
};
// 定义具体产品类 A
class ProductA : public Product {
public:
void use() override {
cout << "使用产品 A" << endl;
}
};
// 定义具体产品类 B
class ProductB : public Product {
public:
void use() override {
cout << "使用产品 B" << endl;
}
};
// 定义抽象工厂类
class Factory {
public:
virtual Product* createProduct() = 0;
};
// 定义具体工厂类 A
class FactoryA : public Factory {
public:
Product* createProduct() override {
return new ProductA();
}
};
// 定义具体工厂类 B
class FactoryB : public Factory {
public:
Product* createProduct() override {
return new ProductB();
}
};
int main() {
// 创建工厂 A 和产品 A
Factory* factoryA = new FactoryA();
Product* productA = factoryA->createProduct();
productA->use();
// 创建工厂 B 和产品 B
Factory* factoryB = new FactoryB();
Product* productB = factoryB->createProduct();
productB->use();
// 释放内存
delete factoryA;
delete factoryB;
delete productA;
delete productB;
return 0;
}
4、抽象工厂模式(Abstract Factory Pattern):提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们具体的类。例如,一个家具生产商可以定义一个抽象工厂接口,让不同的子类工厂来创建不同种类的家具。
// 抽象产品接口
class AbstractProductA {
public:
virtual void operationA() = 0;
};
// 具体产品A1
class ConcreteProductA1 : public AbstractProductA {
public:
void operationA() override {
// 实现具体产品A1的操作
}
};
// 具体产品A2
class ConcreteProductA2 : public AbstractProductA {
public:
void operationA() override {
// 实现具体产品A2的操作
}
};
// 抽象产品接口
class AbstractProductB {
public:
virtual void operationB() = 0;
};
// 具体产品B1
class ConcreteProductB1 : public AbstractProductB {
public:
void operationB() override {
// 实现具体产品B1的操作
}
};
// 具体产品B2
class ConcreteProductB2 : public AbstractProductB {
public:
void operationB() override {
// 实现具体产品B2的操作
}
};
// 抽象工厂接口
class AbstractFactory {
public:
virtual AbstractProductA* createProductA() = 0;
virtual AbstractProductB* createProductB() = 0;
};
// 具体工厂1,创建产品族1的产品
class ConcreteFactory1 : public AbstractFactory {
public:
AbstractProductA* createProductA() override {
return new ConcreteProductA1();
}
AbstractProductB* createProductB() override {
return new ConcreteProductB1();
}
};
// 具体工厂2,创建产品族2的产品
class ConcreteFactory2 : public AbstractFactory {
public:
AbstractProductA* createProductA() override {
return new ConcreteProductA2();
}
AbstractProductB* createProductB() override {
return new ConcreteProductB2();
}
};
5、原型模式(Prototype Pattern):用原型实例指定创建对象的种类,并且通过拷贝这些原型创建新的对象。例如,在游戏开发中,可以使用原型模式来创建多个相似的游戏角色。
#include <iostream>
#include <string>
using namespace std;
// 定义抽象原型类
class Prototype {
public:
virtual Prototype* clone() = 0;
};
// 定义具体原型类 A
class ConcretePrototypeA : public Prototype {
public:
Prototype* clone() override {
return new ConcretePrototypeA(*this);
}
};
// 定义具体原型类 B
class ConcretePrototypeB : public Prototype {
public:
Prototype* clone() override {
return new ConcretePrototypeB(*this);
}
};
int main() {
// 创建原型 A,并克隆出新对象
Prototype* prototypeA = new ConcretePrototypeA();
Prototype* cloneA = prototypeA->clone();
// 创建原型 B,并克隆出新对象
Prototype* prototypeB = new ConcretePrototypeB();
Prototype* cloneB = prototypeB->clone();
// 释放内存
delete prototypeA;
delete prototypeB;
delete cloneA;
delete cloneB;
return 0;
}
6、建造者模式(Builder Pattern):将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示。例如,一个房屋建造公司可以定义一个建造者接口,让不同的子类建造者来创建不同类型的房屋。
#include <iostream>
#include <string>
using namespace std;
// 定义产品类
class Product {
public:
void setPartA(const string& partA) {
this->partA = partA;
}
void setPartB(const string& partB) {
this->partB = partB;
}
void setPartC(const string& partC) {
this->partC = partC;
}
void show() {
cout << "部件A: " << partA << endl;
cout << "部件B: " << partB << endl;
cout << "部件C: " << partC << endl;
}
private:
string partA;
string partB;
string partC;
};
// 定义抽象建造者类
class Builder {
public:
virtual void buildPartA() = 0;
virtual void buildPartB() = 0;
virtual void buildPartC() = 0;
virtual Product* getResult() = 0;
};
// 定义具体建造者类 A
class ConcreteBuilderA : public Builder {
public:
void buildPartA() override {
product->setPartA("Part A - Builder A");
}
void buildPartB() override {
product->setPartB("Part B - Builder A");
}
void buildPartC() override {
product->setPartC("Part C - Builder A");
}
Product* getResult() override {
return product;
}
private:
Product* product = new Product();
};
// 定义具体建造者类 B
class ConcreteBuilderB : public Builder {
public:
void buildPartA() override {
product->setPartA("Part A - Builder B");
}
void buildPartB() override {
product->setPartB("Part B - Builder B");
}
void buildPartC() override {
product->setPartC("Part C - Builder B");
}
Product* getResult() override {
return product;
}
private:
Product* product = new Product();
};
// 定义指挥者类
class Director {
public:
void construct(Builder* builder) {
builder->buildPartA();
builder->buildPartB();
builder->buildPartC();
}
};
int main() {
// 使用建造者 A 构建产品
Builder* builderA = new ConcreteBuilderA();
Director directorA;
directorA.construct(builderA);
Product* productA = builderA->getResult();
productA->show();
// 使用建造者 B 构建产品
Builder* builderB = new ConcreteBuilderB();
Director directorB;
directorB.construct(builderB);
Product* productB = builderB->getResult();
productB->show();
// 释放内存
delete builderA;
delete builderB;
delete productA;
delete productB;
return 0;
}
以上代码实现了建造者模式,其中包含六个类:产品类 Product、抽象建造者类 Builder、具体建造者类 ConcreteBuilderA 和 ConcreteBuilderB、指挥者类 Director。
在建造者模式中,产品的构建过程被封装在具体的建造者类中,而指挥者类负责调用建造者类的方法来构建产品。客户端代码只需要创建指挥者对象,并将具体的建造者对象传入指挥者的构造函数中,然后通过指挥者来构建产品。
每个具体的建造者类都实现了抽象建造者类中定义的方法,用于构建不同部分的产品。而产品类负责定义产品的属性和展示方法。
使用建造者模式可以将产品的构建过程与产品本身解耦,使得构建过程可以独立于产品的组装方式。同时,通过不同的具体建造者可以构建出不同的产品变体,灵活性更高。
在示例代码中,使用了两个具体的建造者类 ConcreteBuilderA 和 ConcreteBuilderB 来构建两个不同的产品。指挥者类 Director 负责调用具体建造者的方法来构建产品。最终通过调用 getResult 方法获取构建好的产品,并展示其属性。
请注意在使用完毕后,需要手动释放内存。