• 创建型设计模式- C++实现

    创建型模式

    单例模式

    Abstract

    单例模式是一种对象创建型模式，使用单例模式，可以保证为一个类只生成唯一的实例对象。也就是说，在整个程序空间中，该类只存在一个实例对象。

    GoF对单例模式的定义是：保证一个类、只有一个实例存在，同时提供能对该实例加以访问的全局访问方法。

    How

    1. 构造函数私有化

    2. 提供一个全局的静态方法

    3. 在类中定义一个静态指针，指向本类的变量的静态变量指针

    4. 懒汉式单例getInstance 时new， 饿汉式静态函数申明时new

    5. 如果设计单例模板，必须使用懒汉式单例

    Template

    1. #include
    2. #include 
    3. #include 
    4.  
    5. using namespace std;
    6. template <typename T>
    7. class Singleton
    8. {
    9. public:
    10.  
    11.   template<typename... Args>
    12.   static T* GetInstance(Args&&... args)
    13.   {
    14.       std::call_once(flag, [&]() {
    15.           m_pInstance=new T(std::forward(args)...);
    16.       });
    17.       return m_pInstance;
    18.   }
    19.   static void DestroyInstance()
    20.   {
    21.     delete m_pInstance;
    22.     m_pInstance=nullptr;
    23.   }
    24. private:
    25.   Singleton(void);
    26.   virtual ~Singleton(void);
    27.   Singleton(const Singleton&);
    28.   Singleton& operator =(const Singleton&);
    29. private:
    30.   static T* m_pInstance;
    31.   static std::once_flag flag;
    32. };
    33. template <class T> T* Singleton::m_pInstance=nullptr;
    34. template <class T> std::once_flag Singleton::flag;
    1. struct A
    2. {
    3.   A(){}
    4. };
    5. struct B
    6. {
    7.   B(int x){}
    8. };
    9. struct C
    10. {
    11.   C(int x,double y){}
    12. };
    13.  
    14. void function() {
    15. 	A* a= Singleton::GetInstance();
    16. 	std::cout<<"address :" << a<
    17. }
    18. int main()
    19. {
    20.  
    21. 	auto th1 = new thread(function);
    22. 	auto th2 = new thread(function);
    23. 	th1->join();
    24. 	th2->join();
    25. 	return 0;
    26. }

    简单工厂模式

    Abstract

    简单工厂模式属于类的创建型模式,又叫做静态工厂方法模式。通过专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类。

    角色

    1.工厂（Creator）角色

    简单工厂模式的核心，它负责实现创建所有实例的内部逻辑。工厂类可以被外界直接调用，创建所需的产品对象。

    2.抽象（Product）角色

    简单工厂模式所创建的所有对象的父类，它负责描述所有实例所共有的公共接口。

    3.具体产品（Concrete Product）角色

    简单工厂模式所创建的具体实例对象

    优缺点

    在这个模式中，工厂类是整个模式的关键所在。它包含必要的判断逻辑，能够根据外界给定的信息，决定究竟应该创建哪个具体类的对象。用户在使用时可以直接根据工厂类去创建所需的实例，而无需了解这些对象是如何创建以及如何组织的。有利于整个软件体系结构的优化。不难发现，简单工厂模式的缺点也正体现在其工厂类上，由于工厂类集中了所有实例的创建逻辑，所以“高内聚”方面做的并不好。另外，当系统中的具体产品类不断增多时，可能会出现要求工厂类也要做相应的修改，扩展性并不很好。

    Demo

    1. include "iostream"
    2. using namespace std;
    3.  
    4. //思想： 核心思想是用一个工厂，来根据输入的条件产生不同的类，然后根据不同类的virtual函数得到不同的结果。
    5. //元素分析：
    6. //抽象产品类：水果类
    7. //具体的水果了：香蕉类、苹果类、梨子
    8. //优点 适用于不同情况创建不同的类时
    9. //缺点 客户端必须要知道基类和工厂类，耦合性差 增加一个产品，需要修改工厂类
    10.  
    11. class Fruit
    12. {
    13. public:
    14. 	virtual void getFruit() = 0;
    15.  
    16. protected:
    17. private:
    18. };
    19.  
    20.  
    21. class Banana : public Fruit
    22. {
    23. public:
    24. 	virtual void getFruit()
    25. 	{
    26. 		cout<<"香蕉"<
    27.  
    28. 	}
    29. protected:
    30. private:
    31. };
    32.  
    33.  
    34. class Pear : public Fruit
    35. {
    36. public:
    37. 	virtual void getFruit()
    38. 	{
    39. 		cout<<"梨子"<
    40.  
    41. 	}
    42. protected:
    43. private:
    44. };
    45.  
    46. class Factory 
    47. {
    48. public:
    49. 	static Fruit* Create(char *name)
    50. 	{
    51. 		Fruit *tmp = NULL;
    52. 		if (strcmp(name, "pear") == 0)
    53. 		{
    54. 			tmp = new Pear();
    55. 		}
    56. 		else if (strcmp(name, "banana") == 0)
    57. 		{
    58. 			tmp = new Banana();
    59. 		}
    60. 		else
    61. 		{
    62. 			return NULL;
    63. 		}
    64. 		return tmp;
    65. 	}
    66. protected:
    67. private:
    68. };
    69.  
    70. void main()
    71. {
    72. 	Fruit *pear =  Factory::Create("pear");
    73. 	if (pear == NULL)
    74. 	{
    75. 		cout<<"创建pear失败\n";
    76. 	}
    77. 	pear->getFruit();
    78. 	
    79. 	Fruit *banana =  Factory::Create("banana");
    80. 	banana->getFruit();
    81.  
    82. 	system("pause");

    工厂模式

    Abstract

    工厂方法模式同样属于类的创建型模式又被称为多态工厂模式。工厂方法模式的意义是定义一个创建产品对象的工厂接口，将实际创建工作推迟到子类当中。

    核心工厂类不再负责产品的创建，这样核心类成为一个抽象工厂角色，仅负责具体工厂子类必须实现的接口，这样进一步抽象化的好处是使得工厂方法模式可以使系统在不修改具体工厂角色的情况下引进新的产品。

    角色

    抽象工厂（Creator）角色

    工厂方法模式的核心，任何工厂类都必须实现这个接口。

    具体工厂（Concrete Creator）角色

    具体工厂类是抽象工厂的一个实现，负责实例化产品对象。

    抽象（Product）角色

    工厂方法模式所创建的所有对象的父类，它负责描述所有实例所共有的公共接口。

    具体产品（Concrete Product）角色

    工厂方法模式所创建的具体实例对象

    Compare

    工厂方法模式与简单工厂模式在结构上的不同不是很明显。工厂方法类的核心是一个抽象工厂类，而简单工厂模式把核心放在一个具体类上。

    工厂方法模式之所以有一个别名叫多态性工厂模式是因为具体工厂类都有共同的接口，或者有共同的抽象父类。

    当系统扩展需要添加新的产品对象时，仅仅需要添加一个具体对象以及一个具体工厂对象，原有工厂对象不需要进行任何修改，也不需要修改客户端，很好的符合了“开放－封闭”原则。而简单工厂模式在添加新产品对象后不得不修改工厂方法，扩展性不好。工厂方法模式退化后可以演变成简单工厂模式。

    “开放－封闭”通过添加代码的方式，不是通过修改代码的方式完成功能的增强。

    Demo

    1. #include "iostream"
    2. using namespace std;
    3.  
    4. class Fruit
    5. {
    6. public:
    7. 	virtual void sayname()
    8. 	{
    9. 		cout<<"fruit\n";
    10. 	}
    11. };
    12.  
    13. class FruitFactory
    14. {
    15. public:
    16. 	virtual Fruit* getFruit()
    17. 	{
    18. 		return new Fruit();
    19. 	}
    20. };
    21.  
    22.  
    23. //香蕉
    24. class Banana : public Fruit
    25. {
    26. public:
    27. 	virtual void sayname()
    28. 	{
    29. 		cout<<"Banana \n"<
    30. 	}
    31. };
    32.  
    33. //香蕉工厂
    34. class BananaFactory : public  FruitFactory
    35. {
    36. public:
    37. 	virtual Fruit* getFruit()
    38. 	{
    39. 		return new Banana;
    40. 	}
    41. };
    42.  
    43.  
    44. //苹果
    45. class Apple : public Fruit
    46. {
    47. public:
    48. 	virtual void sayname()
    49. 	{
    50. 		cout<<"Apple \n"<
    51. 	}
    52. };
    53.  
    54. //苹果工厂
    55. class AppleFactory : public  FruitFactory
    56. {
    57. public:
    58. 	virtual Fruit* getFruit()
    59. 	{
    60. 		return new Apple;
    61. 	}
    62. };
    63.  
    64. void main()
    65. {
    66. 	FruitFactory * ff  = NULL;
    67. 	Fruit *fruit = NULL;
    68.  
    69. 	//1
    70. 	ff = new BananaFactory();
    71. 	fruit = ff->getFruit();
    72. 	fruit->sayname();
    73.  
    74. 	delete fruit;
    75. 	delete ff;
    76.  
    77. 	//2苹果
    78. 	ff = new AppleFactory();
    79. 	fruit = ff->getFruit();
    80. 	fruit->sayname();
    81.  
    82. 	delete fruit;
    83. 	delete ff;
    84.  
    85. 	cout<<"hello....\n";
    86. 	system("pause");
    87. }

    抽象工厂

    Abstract

    抽象工厂模式是所有形态的工厂模式中最为抽象和最其一般性的。抽象工厂模式可以向客户端提供一个接口，使得客户端在不必指定产品的具体类型的情况下，能够创建多个产品族的产品对象。

    工厂模式只能生产一个产品。（要么香蕉、要么苹果）

    抽象工厂可以一下生产一个产品族（里面有很多产品组成）

    Role

    1. 抽象工厂（Creator）角色

    抽象工厂模式的核心，包含对多个产品结构的声明，任何工厂类都必须实现这个接口。

    2. 具体工厂（Concrete Creator）角色

    具体工厂类是抽象工厂的一个实现，负责实例化某个产品族中的产品对象。

    3. 抽象（Product）角色

    抽象模式所创建的所有对象的父类，它负责描述所有实例所共有的公共接口。

    4. 具体产品（Concrete Product）角色

    抽象模式所创建的具体实例对象

    Demo

    1. class Fruit
    2. {
    3. public:
    4. 	virtual void sayname()
    5. 	{
    6. 		cout<<"fruit\n";
    7. 	}
    8. };
    9.  
    10. class FruitFactory
    11. {
    12. public:
    13. 	virtual Fruit* getApple()
    14. 	{
    15. 		return new Fruit();
    16. 	}
    17. 	virtual Fruit* getBanana()
    18. 	{
    19. 		return new Fruit();
    20. 	}
    21. };
    22.  
    23. //南方香蕉
    24. class SouthBanana : public Fruit
    25. {
    26. public:
    27. 	virtual void sayname()
    28. 	{
    29. 		cout<<"South Banana \n"<
    30. 	}
    31. };
    32.  
    33.  
    34. //南方苹果
    35. class SouthApple : public Fruit
    36. {
    37. public:
    38. 	virtual void sayname()
    39. 	{
    40. 		cout<<"South Apple \n"<
    41. 	}
    42. };
    43.  
    44.  
    45. //北方香蕉
    46. class NorthBanana : public Fruit
    47. {
    48. public:
    49. 	virtual void sayname()
    50. 	{
    51. 		cout<<"North Banana \n"<
    52. 	}
    53. };
    54.  
    55.  
    56. //北方苹果
    57. class NorthApple : public Fruit
    58. {
    59. public:
    60. 	virtual void sayname()
    61. 	{
    62. 		cout<<"North Apple \n"<
    63. 	}
    64. };
    65.  
    66. class SourthFruitFactory : public FruitFactory
    67. {
    68. public:
    69. 	virtual Fruit* getApple()
    70. 	{
    71. 		return new SouthApple();
    72. 	}
    73. 	virtual Fruit* getBanana()
    74. 	{
    75. 		return new SouthBanana();
    76. 	}
    77. };
    78.  
    79. class NorthFruitFactory : public FruitFactory
    80. {
    81. public:
    82. 	virtual Fruit* getApple()
    83. 	{
    84. 		return new NorthApple();
    85. 	}
    86. 	virtual Fruit* getBanana()
    87. 	{
    88. 		return new NorthBanana();
    89. 	}
    90. };
    91.  
    92. void main()
    93. {	
    94. 	FruitFactory * ff  = NULL;
    95. 	Fruit *fruit = NULL;
    96.  
    97. 	ff = new SourthFruitFactory();
    98. 	fruit = ff->getApple();
    99. 	fruit->sayname();
    100. 	fruit = ff->getBanana();
    101. 	fruit->sayname();
    102.  
    103. 	delete fruit;
    104. 	delete ff;
    105.  
    106. 	ff = new NorthFruitFactory();
    107. 	fruit = ff->getApple();
    108. 	fruit->sayname();
    109. 	fruit = ff->getBanana();
    110. 	fruit->sayname();
    111.  
    112. 	delete fruit;
    113. 	delete ff;
    114.  
    115. 	cout<<"hello....\n";
    116. 	system("pause");
    117. }

    建造者模式

    Abstract

    Builder模式是为对象的创建而设计的模式- 创建的是一个复合对象：被创建的对象为一个具有复合属性的复合对象- 关注对象创建的各部分的创建过程：不同的工厂（这里指builder生成器）对产品属性有不同的创建方法。

    Role

    1) Builder：为创建产品各个部分，统一抽象接口。

    2) ConcreteBuilder：具体的创建产品的各个部分，部分A， 部分B，部分C。

    3) Director：构造一个使用Builder接口的对象。

    4) Product：表示被构造的复杂对象。

    ConcreteBuilder创建该产品的内部表示并定义它的装配过程，包含定义组成部件的类，包括将这些部件装配成最终产品的接口。

    Compare

    Factory模式中：

    1、有一个抽象的工厂。

    2、实现一个具体的工厂---汽车工厂。

    3、工厂生产汽车A，得到汽车产品A。

    4、工厂生产汽车B，得到汽车产品B。

    这样做，实现了购买者和生产线的隔离。强调的是结果。

    Builder模式:

    1、引擎工厂生产引擎产品，得到汽车部件A。

    2、轮胎工厂生产轮子产品，得到汽车部件B。

    3、底盘工厂生产车身产品，得到汽车部件C。

    4、将这些部件放到一起，形成刚好能够组装成一辆汽车的整体。

    5、将这个整体送到汽车组装工厂，得到一个汽车产品。

    这样做，目的是为了实现复杂对象生产线和其部件的解耦。强调的是过程

    两者的区别在于：

    Factory模式不考虑对象的组装过程，而直接生成一个我想要的对象。

    Builder模式先一个个的创建对象的每一个部件，再统一组装成一个对象。

    Factory模式所解决的问题是，工厂生产产品。

    而Builder模式所解决的问题是工厂控制产品生成器组装各个部件的过程，然后从产品生成器中得到产品。

    Demo

    1. #include 
    2. using namespace std;
    3. #include "string"
    4. class House
    5. {
    6. public:
    7. 	void setFloor(string floor)
    8. 	{
    9. 		this->m_floor = floor;
    10. 	}
    11. 	void setWall(string wall)
    12. 	{
    13. 		this->m_wall = wall;
    14. 	}
    15. 	void setDoor(string door)
    16. 	{
    17. 		this->m_door = door;
    18. 	}
    19.  
    20. 	//
    21. 	string getFloor()
    22. 	{
    23. 		return m_floor;
    24. 	}
    25. 	string setWall()
    26. 	{
    27. 		return  m_wall;
    28. 	}
    29. 	string setDoor()
    30. 	{
    31. 		return m_door;
    32. 	}
    33.  
    34. protected:
    35. private:
    36. 	string	m_floor;
    37. 	string	m_wall;
    38. 	string	m_door;
    39. };
    40.  
    41. class Builder
    42. {
    43. public:
    44. 	virtual void makeFloor() = 0;
    45. 	virtual void makeWall() =  0;
    46. 	virtual void makeDoor() = 0;
    47. 	virtual House *GetHouse() = 0;
    48. };
    49.  
    50. //公寓
    51. class FlatBuild : public Builder
    52. {
    53. public:
    54. 	FlatBuild()
    55. 	{
    56. 		pHouse = new House;
    57. 	}
    58. 	virtual void makeFloor()
    59. 	{
    60. 		pHouse->setFloor("flat Door");
    61. 	}
    62. 	virtual void makeWall()
    63. 	{
    64. 		pHouse->setWall("flat Wall");
    65. 	}
    66. 	virtual void makeDoor()
    67. 	{
    68. 		pHouse->setDoor("flat Door");
    69. 	}
    70. 	virtual House *GetHouse()
    71. 	{
    72. 		return pHouse;
    73. 	}
    74.  
    75. private:
    76. 	House *pHouse;
    77. };
    78.  
    79. //别墅
    80. class VillaBuild : public Builder
    81. {
    82. public:
    83. 	VillaBuild()
    84. 	{
    85. 		pHouse = new House;
    86. 	}
    87. 	virtual void makeFloor()
    88. 	{
    89. 		pHouse->setFloor("villa floor");
    90. 	}
    91. 	virtual void makeWall()
    92. 	{
    93. 		pHouse->setWall("villa Wall");
    94. 	}
    95. 	virtual void makeDoor()
    96. 	{
    97. 		pHouse->setDoor("villa Door");
    98. 	}
    99. 	virtual House *GetHouse()
    100. 	{
    101. 		return pHouse;
    102. 	}
    103. private:
    104. 	House *pHouse;
    105. };
    106.  
    107. class Director
    108. {
    109. public:
    110. 	void Construct(Builder *builder)
    111. 	{
    112. 		builder->makeFloor();
    113. 		builder->makeWall();
    114. 		builder->makeDoor();
    115. 	}
    116. protected:
    117. private:
    118. };
    119.  
    120.  
    121. void main()
    122. {
    123. 	//客户直接造房子
    124. 	House *pHose = new House;
    125. 	pHose->setDoor("wbm门");
    126. 	pHose->setFloor("wbmFloor");
    127. 	pHose->setWall("wbmWall");
    128. 	delete pHose;
    129.  
    130. 	
    131. 	/* //工程队直接造房子 
    132. 	Builder *builder = new FlatBuild;
    133. 	builder->makeFloor();
    134. 	builder->makeWall();
    135. 	builder->makeDoor();
    136. 	*/
    137.  
    138. 	//指挥者（设计师）指挥 工程队 和 建房子
    139. 	Director *director = new Director;
    140.  
    141. 	//建公寓
    142. 	Builder *builder = new FlatBuild;
    143. 	director->Construct(builder); //设计师 指挥 工程队干活
    144. 	House *house = builder->GetHouse();
    145. 	cout << house->getFloor() << endl;
    146. 	delete house;
    147. 	delete builder;
    148.  
    149. 	//建别墅
    150. 	builder = new VillaBuild;
    151. 	director->Construct(builder); //设计师 指挥 工程队干活
    152. 	house = builder->GetHouse();
    153. 	cout << house->getFloor() << endl;
    154. 	delete house;
    155. 	delete builder;
    156. 	
    157. 	delete director;
    158. 	
    159. 	system("pause");
    160. 	return ;
    161. }

    原型模式prototype

    Abstract

    Prototype模式是一种对象创建型模式，它采取复制原型对象的方法来创建对象的实例。使用Prototype模式创建的实例，具有与原型一样的数据。

    1）由原型对象自身创建目标对象。也就是说，对象创建这一动作发自原型对象本身。

    2）目标对象是原型对象的一个克隆。也就是说，通过Prototype模式创建的对象，不仅仅与原型对象具有相同的结构，还与原型对象具有相同的值。

    3）根据对象克隆深度层次的不同，有浅度克隆与深度克隆。

    Demo

    1. class Person
    2. {
    3. public:
    4. 	virtual Person *Clone() = 0;
    5. 	virtual void printT() = 0;
    6.  
    7. };
    8.  
    9. class JavaProgrammer : public Person
    10. {
    11. public:
    12. 	JavaProgrammer()
    13. 	{
    14. 		this->m_name = "";
    15. 		this->m_age = 0;
    16. 		m_resume = NULL;
    17. 	}
    18. 	JavaProgrammer(string name, int age)
    19. 	{
    20. 		this->m_name = name;
    21. 		this->m_age = age;
    22. 		m_resume = NULL;
    23. 	}
    24.  
    25. 	~JavaProgrammer()
    26. 	{
    27. 		if (m_resume!= NULL)
    28. 		{
    29. 			free(m_resume);
    30. 			m_resume = NULL;
    31. 		}
    32. 	}
    33. 	virtual Person *Clone()
    34. 	{
    35. 		JavaProgrammer *p = new JavaProgrammer;
    36. 		*p = *this;
    37. 		return p;
    38. 	}
    39.  
    40. 	void setResume(char *resume)
    41. 	{
    42. 		m_resume = new char[strlen(resume) + 1];
    43. 		strcpy(m_resume, resume);
    44. 	}
    45.  
    46. 	virtual void printT()
    47. 	{
    48. 		cout << "m_name:" << m_name << "\t" << "m_age:" << m_age << endl;
    49. 		if (m_resume != NULL)
    50. 		{
    51. 			cout << m_resume << endl;
    52. 		}
    53. 	}
    54. protected:
    55. private:
    56. 	string	m_name;
    57. 	int		m_age;
    58. 	char	*m_resume;
    59. };
    60.  
    61. void main()
    62. {
    63. 	JavaProgrammer javaperson1("张三", 30);
    64. 	javaperson1.setResume("我是java程序员");
    65. 	Person *p2 = javaperson1.Clone();  //对象具有自我复制功能 注意深拷贝和浅拷贝问题
    66. 	p2->printT();
    67.  
    68. 	delete p2;
    69. 	
    70. 	cout<<"hello..."<
    71. 	system("pause");
    72. 	return ;
    73. }

  • 相关阅读:
    CSS3转换属性—transform之translate、rotate、scale函数详解
    多数据源配置代码
    Day 00 python基础认识与软件安装
    linux_mysql安装教程带安装包(亲测有效)
    JMeter入门教程(10) --函数助手
    git基本操作
    Leetcode刷题详解——全排列 II
    树、二叉树概念(+堆的实现)
    STM32G030F6P6点灯闪烁
    WSL2外部网络设置
  • 原文地址：https://blog.csdn.net/qq_32378713/article/details/126137197