软件架构设计师-创建型模式-单例模式-原型模式-工厂方法模式-抽象工厂模式-建造者模式

文章目录

1.单例模式
2.原型模式
3.工厂方法（Factory Method）模式
4.抽象工厂（AbstractFactory）模式
5.建造者（Builder）模式
6.作者答疑

在面向对象编程的实践中，面临大量的面向对象的创建，将这类创建的方法归类为创建型模式，创建型设计模式的主要关注点是“怎么创建对象”，它的主要特点是“将对象的创建与使用分离”。这样可以降低系统的耦合度，使用者不需要关注对象的创建细节，对象的创建由相关的工厂来完成。就像我们去商城购买商品时，不需要知道商品是怎么生产出来的一样，因为它们由专业的厂商生产。

1.单例模式

单例（Singleton）模式的定义：指一个类只有一个实例，该类能自行创建这个实例的一种模式。例如，Windows 中只能打开一个任务管理器，这样可以避免因打开多个任务管理器窗口而造成内存资源的浪费，或出现各个窗口显示的内容不一致等错误。在计算机系统中，还有 Windows 的回收站、操作系统中的文件系统、多线程中的线程池、显卡的驱动程序对象、打印机的后台处理服务、数据库的连接池、网站的计数器、Web 应用的配置对象、应用程序中的对话框、系统中的缓存等常常被设计成单例。

    #include <iostream>class Singleton {private:Singleton(){std::cout<<"Create Singleton\n";}static Singleton* s;public:static Singleton* getInstance(){return s;}};Singleton* Singleton::s=new Singleton();//global init

2.原型模式

原型（Prototype）模式的定义如下：用一个已经创建的实例作为原型，通过复制该原型对象来创建一个和原型相同或相似的新对象。在这里，原型实例指定了要创建的对象的种类。这种方式创建对象非常高效，根本无需指定对象创建的细节。例如，Windows 操作系统的安装通常比较耗时，如果复制就快了很多。当直接创建对象的代价比较大时，则采用这种模式。例如，一个对象需要在一个高代价的数据库操作之后被创建。我们可以缓存该对象，在下一个请求时返回它的克隆，在需要的时候更新数据库，以此来减少数据库调用。

      #include <cstdlib>class Prototype {public:int *ip=(int*)malloc(sizeof(int));int counter=100;virtual Prototype* clone()=0;};class cloneablePrototype:public Prototype{public:cloneablePrototype();Prototype* clone();private:cloneablePrototype(const cloneablePrototype&);//copycloneablePrototype& operator=(cloneablePrototype const& cloneablePrototype1 );//ban on =operator};cloneablePrototype::cloneablePrototype() {}Prototype *cloneablePrototype::clone() {return new cloneablePrototype(*this);}cloneablePrototype:: cloneablePrototype(const cloneablePrototype& c){//pass your stack value and heap value herecounter=c.counter;*(ip)=*(c.ip);}//copy

3.工厂方法（Factory Method）模式

工厂方法模式的定义：定义一个创建产品对象的工厂接口，将产品对象的实际创建工作推迟都具体工厂类中。当满足创建型模式中所要求的“创建与使用相分离”的特点。特点：使用工厂来控制子类的实例化，应用：我们明确地计划不同条件下创建不同实例时。

    #include<iostream>class Product{public:virtual void getType(){std::cout<<"base type\n";};};class ProductA:public Product {public:void getType();};class ProductB:public Product {public:void getType();};class ProductC:public Product {public:void getType();};class Factory {public:Product* getProduct(char t);};Product* Factory::getProduct(char t){std::cout<<"producing "<<t<<std::endl;switch (t){case 'A':return new ProductA();case 'B':return new ProductB();case 'C':return new ProductC();default:return nullptr;}}void ProductA::getType() {std::cout<<"my type is A\n";}void ProductB::getType() {std::cout<<"my type is B\n";}void ProductC::getType() {std::cout<<"my type is C\n";}

4.抽象工厂（AbstractFactory）模式

抽象工厂模式的定义：是一种为访问类提供一个创建一组相关或相互依赖对象的接口，其访问类无须指定所要产品的具体类就能得到同族的不同等级的产品的模式结构。属于二级结构的工厂模式，每一类产品为工厂模式创建，然后将不同类产品归结到同一个工厂模式内部使用。

# include < iostream >
//product
class laptop
{public:virtual void info() = 0;laptop();virtual~laptop();
};
class smartphone
{public:virtual void info() = 0;smartphone();virtual~smartphone();
};
class samsungLaptop: public laptop
{public:void info(){std::cout << "laptop made by samsung\n";}
};
class samsungSmartphone: public smartphone
{public:void info(){std::cout << "smartphone made by samsung\n";}
};
class appleLaptop: public laptop
{public:void info(){std::cout << "laptop made by apple\n";}
};
class appleSmartphone: public smartphone
{public:void info(){std::cout << "smartphone made by apple\n";}
};
//factory
class AbstractFactory
{public:virtual smartphone *makePhone() = 0;virtual laptop *makeLaptop() = 0;virtual~AbstractFactory();
};
class samsungFactory: public AbstractFactory
{public:smartphone *makePhone(){return new samsungSmartphone();}laptop *makeLaptop(){return new samsungLaptop();}
};
class appleFactory: public AbstractFactory
{public:smartphone *makePhone(){return new appleSmartphone();}laptop *makeLaptop(){return new appleLaptop();}
};
aptop::laptop() {}
laptop::~laptop() {}
smartphone::smartphone() {}
smartphone::~smartphone() {}
AbstractFactory::~AbstractFactory() {}

5.建造者（Builder）模式

在软件开发过程中有时需要创建一个复杂对象，这个复杂对象通常由多个子部件按一定的步骤组成而已。例如，计算机有 CPU、主板、内存、硬盘、显卡、机箱、显示器、键盘、鼠标等部件组装而成的，采购员不可能自己去组装计算机，而是将计算机的配置要求告诉计算机销售公司，计算机销售公司安排技术人员去组装计算机，然后再交给要买计算机的采购员。建造者Builder 模式要解决的问题是：当我们要创建的对象很复杂的时候（通常是由很多其他的对象组合而成），我们要要复杂对象的创建过程和这个对象的表示（展示）分离开来，这样做的好处就是通过一步步的进行复杂对象的构建，由于在每一步的构造过程中可以引入参数，使得经过相同的步骤创建最后得到的对象的展示不一样。

#pragma once
#include<iostream>
#include<string>
using namespace std;
class House {public:virtual void setWall(const string& str) = 0;virtual void setWindow(const string& str) = 0;virtual void setDoor(const string& str) = 0;virtual void setRoom(const string& str) = 0;virtual void show() = 0;virtual ~House() {}string wall, Window, door, room;
};
class HouseBuild {public:virtual House* GetResult() = 0;virtual void BuildWall() = 0;virtual void BuildWindow() = 0;virtual void BuildDoor() = 0;virtual void BuildRoom() = 0;virtual ~HouseBuild() {}
};class StoneHouse :public House {public:void setWall(const string& str) override{this->wall = str;}void setWindow(const string& str) override {this->Window = str;}void setDoor(const string& str) override {this->door = str;}void setRoom(const string& str) override {this->room = str;}void show()override {cout << "Stone House data:" << "wall=" << wall << ",  window=" << Window << ",  door=" << door << ",  room=" <<room<< endl;}
};class StoneHouseBuild :public HouseBuild {public:StoneHouseBuild(StoneHouse* pStoneHouse) {this->pStoneHouse = pStoneHouse;}void BuildWall() override{cout << "Stone Wall" << endl;pStoneHouse->setWall("Stonewall");}void BuildWindow() override {cout << "Stone Window" << endl;pStoneHouse->setWindow("Stonewindow");}void BuildDoor() override {cout << "Stone Door" << endl;pStoneHouse->setDoor("Stonedoor");}void BuildRoom() override {cout << "Stone Room" << endl;pStoneHouse->setRoom("Stoneroom");}House* GetResult()override {return pStoneHouse;}~StoneHouseBuild() {delete pStoneHouse;this->pStoneHouse = nullptr;}
private:StoneHouse* pStoneHouse;
};class WoodHouse :public House {public:void setWall(const string& str) override {this->wall = str;}void setWindow(const string& str) override {this->Window = str;}void setDoor(const string& str) override {this->door = str;}void setRoom(const string& str) override {this->room = str;}void show()override {cout << "Wood House data:" << "wall=" << wall << ",  window=" << Window << ",  door=" << door << ",  room=" <<room<< endl;}
};
class WoodHouseBuild :public HouseBuild {public:WoodHouseBuild(WoodHouse* pWoodHouse) {this->pWoodHouse = pWoodHouse;}void BuildWall() override {cout << "Wood Wall" << endl;pWoodHouse->setWall("Woodwall");}void BuildWindow() override {cout << "Wood Window" << endl;pWoodHouse->setWindow("Woodwindow");}void BuildDoor() override {cout << "Wood Door" << endl;pWoodHouse->setDoor("Wooddoor");}void BuildRoom() override {cout << "Wood Room" << endl;pWoodHouse->setRoom("Woodroom");}House* GetResult()override {return pWoodHouse;}~WoodHouseBuild() {delete pWoodHouse;this->pWoodHouse = nullptr;}
private:WoodHouse* pWoodHouse;
};

在这里，以建房子为例。其中建房子的顺序是一致的，都是Wall、Window、Door、Room，这部分是固定的，因此把该部分整体抽出来在另一个抽象基类HouseBuild中执行，实现分离。每种类型的房子都继承自抽象基类House，对应的建房子算法继承自抽象基类HouseBuild。

#include<iostream>
#include"Build.h"
using namespace std;class HouseDirector {public:HouseBuild* pHouseBuild;HouseDirector(HouseBuild* pHouseBuild){this->pHouseBuild = pHouseBuild;}//流程一样，稳定的House* Construct() {pHouseBuild->BuildWall();pHouseBuild->BuildWindow();pHouseBuild->BuildDoor();pHouseBuild->BuildRoom();return pHouseBuild->GetResult();}~HouseDirector() {delete pHouseBuild;this->pHouseBuild = nullptr;}
};int main()
{HouseBuild* pHouse1 = new StoneHouseBuild(new StoneHouse());HouseDirector* director1 = new HouseDirector(pHouse1);director1->Construct()->show();cout << "===========" << endl;HouseBuild* pHouse2 = new WoodHouseBuild(new WoodHouse());HouseDirector* director2 = new HouseDirector(pHouse2);director2->Construct()->show();return 0;
}

其中Construct方法就是稳定不变的。这样就实现了构建和表示的分离。面向对象设计模式体现的是抽象具体类行为的一致性。
这些构建模式，体现了基类中抽象了一般的，规律性的属性和方法，而具体的实现则推迟到子类中去实现，其中基类的设计体现着软件实现中最重要的部分。
合理的脚本代码可以有效的提高工作效率，减少重复劳动。

6.作者答疑

如有疑问，请留言。