创建型设计模式（C++）

迪丽瓦拉

2024-05-30 14:56:05

0次

文章目录

1.简单工厂模式&静态工厂模式
2.工厂方法模式
3.抽象工厂模式
4.原型模式
5.单例模式
- a.饿汉式
- b.懒汉式
6.建造者模式

在这里插入图片描述

创建型模式提供了创建对象的机制，旨在提升已有代码的灵活性和可复用性。

部分插图来自： https://refactoringguru.cn/design-patterns/catalog

1.简单工厂模式&静态工厂模式

简单工厂模式严格来说并不是一种设计模式，而更像是一种编程习惯。简单工厂模式在创建对象时不会对客户端暴露创建逻辑，而是通过使用一个共同的接口来提供新创建的对象。当这个提供对象接口被定义为静态方法时，简单工厂模式也被称为静态工厂模式。

简单工厂模式包含如下角色：

抽象产品：定义产品规范，描述产品主要特性和功能，是所有具体产品的基类。
具体产品：实现或者继承抽象产品。
具体工厂：提供了创建产品的方法，调用者通过该方法来获取产品。

简单工厂的优点：

封装了创建对象的过程，当一个调用者想创建一个对象时只需要知道其名称就可以了。
对象创建和业务逻辑被分开，如果要添加新产品只需要修改工厂类，而不需要在原代码中修改。降低了客户代码修改的可能性，在一定程度上增加了代码的可扩展性。

简单工厂的缺点：增加新产品时需要修改工厂类的代码，违背了开闭原则（对扩展开放，对修改封闭）。

#include /* 猫基类 */
class Cat {
public:virtual void bark() = 0;virtual ~Cat() = default;
};/* 狸花猫 */
class DragonLi : public Cat {
public:void bark() override {std::cout << "DragonLi: meow~" << std::endl;}
};/* 缅因猫 */
class MaineCoon : public Cat {
public:void bark() override {std::cout << "MaineCoon: meow~" << std::endl;}
};/* 布偶猫 */
class Ragdoll : public Cat {
public:void bark() override {std::cout << "Ragdoll: meow~" << std::endl;}
};/* 静态工厂类 专门用来生产猫咪 */
class SimpleCatFactory {
public:static Cat *CreateCat(const std::string &category) {if (category == "DragonLi") {return new DragonLi();} else if (category == "MaineCoon") {return new MaineCoon();} else {return new Ragdoll();}}
};int main() {Cat *dragonLi = SimpleCatFactory::CreateCat("DragonLi");dragonLi->bark();Cat *maineCoon = SimpleCatFactory::CreateCat("MaineCoon");maineCoon->bark();Cat *ragdoll = SimpleCatFactory::CreateCat("Ragdoll");ragdoll->bark();delete dragonLi;delete maineCoon;delete ragdoll;return 0;
}

atreus@MacBook-Pro % clang++ main.cpp -o main -std=c++11
atreus@MacBook-Pro % ./main 
DragonLi: meow~
MaineCoon: meow~
Ragdoll: meow~
atreus@MacBook-Pro %

2.工厂方法模式

工厂方法模式是一种创建型设计模式，其在父类中提供一个创建对象的方法接口，允许子类决定所要实例化对象的类型。工厂方法模式使一个产品类的实例化延迟到工厂的子类中进行。

在这里插入图片描述

工厂方法模式包含如下角色：

抽象产品：定义产品规范，描述产品主要特性和功能，是所有具体产品的基类。
具体产品：实现或者继承抽象产品，由具体工厂来创建，与具体工厂之间一一对应。
抽象工厂：提供了创建产品的接口，调用者通用它访问具体工厂的工厂方法来创建产品。
具体工厂：主要是实现抽象工厂中的抽象方法，完成具体产品的创建。

工厂方法模式的优点：

用户只需要知道具体工厂的名称就可以得到想要的产品，而无需知道产品的具体创建过程，从而避免了用户和具体产品之间的紧密耦合。
可以将产品创建代码放在程序的单一位置，从而使得代码更容易维护，满足单一职责原则。
在系统增加新的产品时只需要添加具体产品类和对应的具体工厂类，无须对原工厂进行任何修改，满足开闭原则。

工厂方法模式的缺点：每增加一个产品就要增加一个具体产品类和一个对应的具体工厂类，增加了系统的复杂度。

#include /* 猫基类 */
class Cat {
public:virtual void bark() = 0;virtual ~Cat() = default;
};/* 狸花猫 */
class DragonLi : public Cat {
public:void bark() override {std::cout << "DragonLi: meow~" << std::endl;}
};/* 缅因猫 */
class MaineCoon : public Cat {
public:void bark() override {std::cout << "MaineCoon: meow~" << std::endl;}
};/* 抽象工厂类 */
class CatFactory {
public:virtual Cat *CreateCat() = 0;virtual ~CatFactory() = default;
};class DragonLiFactory : public CatFactory {
public:Cat *CreateCat() override {return new DragonLi();}
};class MaineCoonFactory : public CatFactory {
public:Cat *CreateCat() override {return new MaineCoon();}
};int main() {CatFactory *dragonLiFactory = new DragonLiFactory();Cat *dragonLi = dragonLiFactory->CreateCat();dragonLi->bark();delete dragonLi;delete dragonLiFactory;CatFactory *maineCoonFactory = new MaineCoonFactory();Cat *maineCoon = maineCoonFactory->CreateCat();maineCoon->bark();delete maineCoon;delete maineCoonFactory;return 0;
}

atreus@MacBook-Pro % clang++ main.cpp -o main -std=c++11
atreus@MacBook-Pro % ./main                             
DragonLi: meow~
MaineCoon: meow~
atreus@MacBook-Pro %

3.抽象工厂模式

抽象工厂模式是工厂方法模式的升级版本，工厂方法模式只生产某个单一的产品，而抽象工厂模式可生产一系列相关的产品。

在这里插入图片描述

抽象工厂模式包含如下角色：

抽象产品：定义产品规范，描述产品主要特性和功能，是所有具体产品的基类。
具体产品：实现或者继承抽象产品，由具体工厂来创建，与具体工厂之间是多对一的关系。
抽象工厂：提供了创建产品的接口，调用者通用它访问具体工厂的工厂方法来创建一系列相关的产品。
具体工厂：主要是实现抽象工厂中的抽象方法，完成具体产品的创建。

抽象工厂方法模式的优点：

可以确保同一工厂生成的产品相互匹配，比如下例中的美国工厂不会生产出日本战舰。
可以避免客户端和具体产品代码的耦合。
基于工厂方法模式改进，同样满足单一职责原则和开闭原则。

抽象工厂方法模式的缺点：代码较为复杂，当产品族中需要增加一个新的产品时，所有的工厂类都需要进行修改。比如我们在下面代码中添加一个有关驱逐舰的方法，包括抽象工厂在内的工厂类都需要进行修改。

#include /* 战列舰基类 */
class Battleship {
public:virtual void fire() = 0;virtual ~Battleship() = default;
};/* 巡洋舰基类 */
class Cruiser {
public:virtual void fire() = 0;virtual ~Cruiser() = default;
};/* 抽象工厂类 */
class AbstractFactory {
public:virtual Battleship *createBattleship() = 0;virtual Cruiser *createCruiser() = 0;virtual ~AbstractFactory() = default;
};/* 衣阿华级战列舰 美国 */
class Iowa : public Battleship {
public:void fire() override {std::cout << "Iowa: fire!" << std::endl;}
};/* 得梅因级巡洋舰 美国 */
class DesMoines : public Cruiser {
public:void fire() override {std::cout << "DesMoines: fire!" << std::endl;}
};/* 大和级战列舰 日本 */
class Yamato : public Battleship {
public:void fire() override {std::cout << "Yamato: fire!" << std::endl;}
};/* 伊吹级巡洋舰 日本 */
class Ibuki : public Cruiser {
public:void fire() override {std::cout << "Ibuki: fire!" << std::endl;}
};/* 美国工厂类 */
class AmericanFactory : public AbstractFactory {
public:Battleship *createBattleship() override {return new Iowa;}Cruiser *createCruiser() override {return new DesMoines;}
};/* 日本工厂类 */
class JapaneseFactory : public AbstractFactory {
public:Battleship *createBattleship() override {return new Yamato;}Cruiser *createCruiser() override {return new Ibuki;}
};int main() {AbstractFactory *americanFactory = new AmericanFactory;Battleship *iowa = americanFactory->createBattleship();iowa->fire();delete iowa;delete americanFactory;AbstractFactory *japaneseFactory = new JapaneseFactory;Cruiser *ibuki = japaneseFactory->createCruiser();ibuki->fire();delete ibuki;delete japaneseFactory;return 0;
}

atreus@MacBook-Pro % clang++ main.cpp -o main -std=c++11
atreus@MacBook-Pro % ./main                             
Iowa: fire!
Ibuki: fire!
atreus@MacBook-Pro %

4.原型模式

用一个已经创建的实例作为原型，通过复制该原型对象来创建一个和原型对象相同的新对象。

原型模式包含如下角色：

抽象原型类：规定了具体原型对象必须实现的的 clone() 方法。
具体原型类：实现抽象原型类的 clone() 方法，它是可被复制的对象。
访问类：使用具体原型类中的 clone() 方法来复制新的对象。

#include /* 抽象原型类 */
class Prototype {
public:virtual Prototype *clone() = 0;virtual ~Prototype() = default;
};/* 猫咪类 */
class Cat : public Prototype {
public:Cat() = default;/* 深拷贝 */Cat *clone() override {return new Cat();}/* 浅拷贝 */// Cat *clone() override {//    return this;// }
};int main() {Cat *oldCat = new Cat();Cat *newCat = oldCat->clone();std::cout << oldCat << std::endl;std::cout << newCat << std::endl;delete oldCat;delete newCat;return 0;
}

atreus@MacBook-Pro % clang++ main.cpp -o main -std=c++11
atreus@MacBook-Pro % ./main 
0x60000321c040
0x60000321c050
atreus@MacBook-Pro %

5.单例模式

单例模式只涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类会提供一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

单例模式包含如下角色：

单例类：只能创建一个实例的类；
访问类：使用单例类。

单例设计模式分类两种：

饿汉式：类加载时就会创建该单实例对象。缺点是单例创建后不一定会立即被使用，会造成一定的内存浪费；
懒汉式：单实例对象不会在类加载时被创建，而是在首次使用该对象时创建。缺点是在多线程情况下需要着重考虑线程安全问题。

a.饿汉式

#include /* 通过静态变量实现的单例类 */
class Cat {
private:/* 让构造函数私有以避免类被实例化 */Cat() = default;/* 类对应的唯一的对象 */static Cat *m_instance;public:/* 实例对象的唯一访问方式 */static Cat *getInstance() {return m_instance;}
};/* 静态成员变量需要类内定义类外初始化 */
Cat *Cat::m_instance = new Cat;int main() {Cat *dragonLi = Cat::getInstance();Cat *ragdoll = Cat::getInstance();std::cout << dragonLi << std::endl;std::cout << ragdoll << std::endl;delete dragonLi;delete ragdoll; // 由于两个猫咪实际上是一个单例 所以会发成内存的重复释放return 0;
}

atreus@MacBook-Pro % clang++ main.cpp -o main -std=c++11
atreus@MacBook-Pro % ./main                             
0x6000007dc040
0x6000007dc040
main(86372,0x1f801c140) malloc: *** error for object 0x6000007dc040: pointer being freed was not allocated
main(86372,0x1f801c140) malloc: *** set a breakpoint in malloc_error_break to debug
zsh: abort      ./main
atreus@MacBook-Pro %

b.懒汉式

#include /* 通过静态变量实现的单例类 */
class Cat {
private:/* 类对应的唯一的对象 */static Cat *instance;/* 让构造函数私有以避免类被实例化 */Cat() = default;public:/* 实例对象的唯一访问方式 */static Cat *getInstance() {// 多线程场景下此处需要加锁instance = (instance == nullptr) ? new Cat : instance;return instance;}
};/* 静态成员变量需要类内定义类外初始化 */
Cat *Cat::instance = nullptr;int main() {Cat *dragonLi = Cat::getInstance();Cat *ragdoll = Cat::getInstance();std::cout << dragonLi << std::endl;std::cout << ragdoll << std::endl;delete dragonLi;delete ragdoll; // 由于两个猫咪实际上是一个单例 所以会发成内存的重复释放return 0;
}

atreus@MacBook-Pro % clang++ main.cpp -o main -std=c++11
atreus@MacBook-Pro % ./main                             
0x600003c18040
0x600003c18040
main(75509,0x1f801c140) malloc: *** error for object 0x600003c18040: pointer being freed was not allocated
main(75509,0x1f801c140) malloc: *** set a breakpoint in malloc_error_break to debug
zsh: abort      ./main
atreus@MacBook-Pro %

通常，为了避免上述类似的对同一单例的多次释放，可以将单例模式与 RAII 机制结合使用：

/* 以 RAII 方式来控制单例 */
class CatStoreRAII {
public:Cat *m_cat;CatStore() {m_cat = Cat::getInstance();}~CatStore() {delete m_cat;}Cat *getCat() {return m_cat;}
};

6.建造者模式

将一个复杂对象的构建与表示分离，使得同样的构建过程可以创建不同的表示。

建造者模式包含如下角色：

抽象建造者类：这个接口规定要实现复杂对象的那些部分的创建，并不涉及具体的部件对象的创建。
具体建造者类：实现建造者接口，完成复杂产品的各个部件的具体创建方法，并在构造过程完成后，提供产品的实例。
产品类：要创建的复杂对象。
指挥者类：调用具体建造者来创建复杂对象的各个部分，在指导者中不涉及具体产品的信息，只负责保证对象各部分完整创建或按某种顺序创建。

建造者模式的优点：

建造者模式的封装性很好。使用建造者模式可以有效的封装变化，在使用建造者模式的场景中，一般产品类和建造者类是比较稳定的，因此，将主要的业务逻辑封装在指挥者类中对整体而言可以取得比较好的稳定性。
在建造者模式中，客户端不必知道产品内部组成的细节，将产品本身与产品的创建过程解耦，使得相同的创建过程可以创建不同的产品对象。
可以更加精细地控制产品的创建过程。将复杂产品的创建步骤分解在不同的方法中，使得创建过程更加清晰，也更方便使用程序来控制创建过程。
建造者模式很容易进行扩展。如果有新的需求，通过实现一个新的建造者类就可以完成，基本上不用修改之前已经测试通过的代码，因此也就不会对原有功能引入风险。符合开闭原则。

建造者模式的缺点：造者模式所创建的产品一般具有较多的共同点，其组成部分相似，如果产品之间的差异性很大，则不适合使用建造者模式，因此其使用范围受到一定的限制

#include 
#include using namespace std;/* 产品类 */
class Cat {
private:string m_leg; // 腿string m_tail; // 尾巴
public:const string &getLeg() const {return m_leg;}void setLeg(const string &leg) {m_leg = leg;}const string &getTail() const {return m_tail;}void setTail(const string &tail) {m_tail = tail;}
};/* 抽象建造者 */
class Builder {
protected:Cat *m_cat = new Cat();public:virtual void buildLeg() = 0;virtual void buildTail() = 0;virtual Cat *createCat() = 0;virtual ~Builder() {delete m_cat;}
};/* 具体构建者 */
class DragonLiBuilder : public Builder {
public:void buildLeg() override {m_cat->setLeg("狸");}void buildTail() override {m_cat->setTail("花");}Cat *createCat() override {return m_cat;}
};/* 具体构建者 */
class RagdollBuilder : public Builder {
public:void buildLeg() override {m_cat->setLeg("布");}void buildTail() override {m_cat->setTail("偶");}Cat *createCat() override {return m_cat;}
};/* 指挥者 */
class Director {
private:Builder *m_builder;public:explicit Director(Builder *builder) {m_builder = builder;}Cat *construct() {m_builder->buildLeg();m_builder->buildTail();return m_builder->createCat();}~Director() {delete m_builder;}
};int main() {Director dragonLiDirector(new DragonLiBuilder);Cat *dragonLi = dragonLiDirector.construct();cout << dragonLi->getLeg() << dragonLi->getTail() << endl;Director ragdollDirector(new RagdollBuilder);Cat *ragdoll = ragdollDirector.construct();cout << ragdoll->getLeg() << ragdoll->getTail() << endl;return 0;
}

atreus@MacBook-Pro % clang++ main.cpp -o main -std=c++11
atreus@MacBook-Pro % ./main 
狸花
布偶
atreus@MacBook-Pro %

词库加载错误:未能找到文件“E:\highferrum_mysql\Configuration\Dict_Stopwords.txt”。

上一篇：Kubernetes学习（四）控制器

下一篇：商品价格区间设置与排序--课后程序(Python程序开发案例教程-黑马程序员编著-第4章-课后作业)

创建型设计模式（C++）

文章目录

1.简单工厂模式&静态工厂模式

2.工厂方法模式

3.抽象工厂模式

4.原型模式

5.单例模式

a.饿汉式

b.懒汉式

6.建造者模式

相关内容

热门资讯