• [架构设计] 创建型模型

    目录

    一、简单工厂模式

    二、工厂模式

     三、抽象工厂模式

     四、单例模式

    一、简单工厂模式

    类别描述
    适用场景
    • 工厂类负责创建的对象比较少，由于创建的对象较少，不会造成工厂方法中的业务逻辑太过复杂
    • 客户端只知道传入工厂类的参数，对于如何创建对象并不关心
    优点
    • 实现了对象创建和使用的分离
    缺点
    • 工厂类职责过重
    • 增加系统中类的个数，复杂度增加
    • 违反“开闭原则”，添加新产品需要修改工厂逻辑
    1. #include 
    2. using namespace std;
    3.  
    4. //抽象水果，此处做了核心的工作
    5. class AbstractFruit {
    6. public:
    7. 	virtual void ShowName() = 0;
    8. };
    9.  
    10. //苹果
    11. class Apple :public AbstractFruit {
    12. public:
    13. 	virtual void ShowName() {
    14. 		cout << "我是苹果!" << endl;
    15. 	}
    16. };
    17.  
    18. //香蕉
    19. class Banana :public AbstractFruit {
    20. public:
    21. 	virtual void ShowName() {
    22. 		cout << "我是香蕉!" << endl;
    23. 	}
    24. };
    25.  
    26. //鸭梨
    27. class Pear :public AbstractFruit {
    28. public:
    29. 	virtual void ShowName() {
    30. 		cout << "我是鸭梨!" << endl;
    31. 	}
    32. };
    33.  
    34. //水果工厂
    35. class FruitFactor {
    36. public:
    37. 	static AbstractFruit * CreateFruit(string flag) {
    38. 		if (flag == "apple") {
    39. 			return new Apple;
    40. 		}
    41. 		else if (flag == "banana") {
    42. 			return new Banana;
    43. 		}
    44. 		else if (flag == "pear") {
    45. 			return new Pear;
    46. 		}
    47. 		else {
    48. 			return NULL;
    49. 		}
    50. 	}
    51. };
    52.  
    53. int main(){
    54. 	FruitFactor* factory = new FruitFactor;
    55. 	AbstractFruit* fruit = factory->CreateFruit("apple");
    56. 	fruit->ShowName();
    57. 	delete fruit;
    58.  
    59. 	fruit = factory->CreateFruit("banana");
    60. 	fruit->ShowName();
    61. 	delete fruit;
    62.  
    63. 	fruit = factory->CreateFruit("pear");
    64. 	fruit->ShowName();
    65. 	delete fruit;
    66.  
    67. 	fruit = NULL;
    68. 	delete factory;
    69. 	factory = NULL;
    70. 	return 0;
    71. }

    二、工厂模式

    类别描述
    适用场景
    • 适用于更复杂或更多的创建对象的工厂类
    优点
    • 针对工厂做了进一步抽象，从而让具体的工厂可以在适用的时候再实例化
    • 每个工厂的职责更加单一
    缺点
    • 需要创建很多工厂
    1. #include 
    2. using namespace std;
    3.  
    4. //抽象水果
    5. class AbstractFruit {
    6. public:
    7. 	virtual void ShowName() = 0;
    8. };
    9.  
    10. //苹果
    11. class Apple :public AbstractFruit {
    12. public:
    13. 	virtual void ShowName() {
    14. 		cout << "我是苹果!" << endl;
    15. 	}
    16. };
    17.  
    18. //香蕉
    19. class Banana :public AbstractFruit {
    20. public:
    21. 	virtual void ShowName() {
    22. 		cout << "我是香蕉!" << endl;
    23. 	}
    24. };
    25.  
    26. //鸭梨
    27. class Pear :public AbstractFruit {
    28. public:
    29. 	virtual void ShowName() {
    30. 		cout << "我是鸭梨!" << endl;
    31. 	}
    32. };
    33.  
    34. //抽象工厂，进一步抽象了一层，从而可以让工厂提供统一的接口，而不是具体的实现
    35. class AbstractFruitFactory {
    36. public:
    37. 	virtual AbstractFruit* CreateFruit() = 0;
    38. };
    39.  
    40.  
    41. //苹果工厂
    42. class AppleFactory :public AbstractFruitFactory {
    43. public:
    44. 	virtual AbstractFruit* CreateFruit() {
    45. 		return new Apple;
    46. 	}
    47. };
    48.  
    49. //香蕉工厂
    50. class BananaFactory :public AbstractFruitFactory {
    51. public:
    52. 	virtual AbstractFruit* CreateFruit() {
    53. 		return new Banana;
    54. 	}
    55. };
    56.  
    57. //梨工厂
    58. class PearFactory :public AbstractFruitFactory {
    59. public:
    60. 	virtual AbstractFruit* CreateFruit() {
    61. 		return new Pear;
    62. 	}
    63. };
    64.  
    65.  
    66. int main() {
    67. 	AbstractFruitFactory* factory = NULL;
    68. 	AbstractFruit* fruit = NULL;
    69.  
    70. 	//创建一个苹果工厂
    71. 	factory = new AppleFactory;
    72. 	fruit = factory->CreateFruit();
    73. 	fruit->ShowName();
    74. 	delete fruit;
    75. 	delete factory;
    76.  
    77. 	//创建一个香蕉工厂
    78. 	factory = new BananaFactory;
    79. 	fruit = factory->CreateFruit();
    80. 	fruit->ShowName();
    81. 	delete fruit;
    82. 	delete factory;
    83.  
    84. 	//创建一个鸭梨工厂
    85. 	factory = new PearFactory;
    86. 	fruit = factory->CreateFruit();
    87. 	fruit->ShowName();
    88. 	delete fruit;
    89. 	delete factory;
    90. 	fruit = NULL;
    91. 	factory = NULL;
    92. 	return 0;
    93. }

     三、抽象工厂模式

    类别描述
    适用场景
    • 系统中有多于一个的产品族 （美 日 中，核心还是工厂抽象类一定要稳定）
    • 产品等级结构稳定 （比如增加桃子时，则抽象工厂得修改）
    优点
    • 产品族中的多个对象被设计成一起工作时，它能够保证客户端始终只使用同一个产品族中的对象
    缺点
    • 增加新的产品等级结构麻烦，需要对原有系统进行较大的修改
    1. #include 
    2. using namespace std;
    3.  
    4. //抽象苹果
    5. class AbstractApple {
    6. public:
    7. 	virtual void ShowName() = 0;
    8. };
    9.  
    10. //中国苹果
    11. class ChinaApple :public AbstractApple {
    12. public:
    13. 	virtual void ShowName() {
    14. 		cout << "中国苹果！" << endl;
    15. 	}
    16. };
    17.  
    18. //美国苹果
    19. class USAApple :public AbstractApple {
    20. public:
    21. 	virtual void ShowName() {
    22. 		cout << "美国苹果！" << endl;
    23. 	}
    24. };
    25.  
    26. //日本苹果
    27. class JapanApple :public AbstractApple {
    28. public:
    29. 	virtual void ShowName() {
    30. 		cout << "日本苹果！" << endl;
    31. 	}
    32. };
    33.  
    34. //抽象香蕉
    35. class AbstractBanana {
    36. public:
    37. 	virtual void ShowName() = 0;
    38. };
    39.  
    40. //中国香蕉
    41. class ChinaBanana :public AbstractBanana {
    42. public:
    43. 	virtual void ShowName() {
    44. 		cout << "中国香蕉！" << endl;
    45. 	}
    46. };
    47.  
    48. //美国香蕉
    49. class USABanan :public AbstractBanana {
    50. public:
    51. 	virtual void ShowName() {
    52. 		cout << "美国香蕉！" << endl;
    53. 	}
    54. };
    55.  
    56. //日本香蕉
    57. class JapanBanan :public AbstractBanana {
    58. public:
    59. 	virtual void ShowName() {
    60. 		cout << "日本香蕉！" << endl;
    61. 	}
    62. };
    63.  
    64. //抽象鸭梨
    65. class AbstractPear {
    66. public:
    67. 	virtual void ShowName() = 0;
    68. };
    69.  
    70.  
    71. //中国鸭梨
    72. class ChinaPear:public AbstractPear{
    73. public:
    74. 	virtual void ShowName() {
    75. 		cout << "中国鸭梨！" << endl;
    76. 	}
    77. };
    78.  
    79. //美国鸭梨
    80. class USAPear :public AbstractPear {
    81. public:
    82. 	virtual void ShowName() {
    83. 		cout << "美国鸭梨！" << endl;
    84. 	}
    85. };
    86.  
    87. //日本鸭梨
    88. class JapanPear :public AbstractPear {
    89. public:
    90. 	virtual void ShowName() {
    91. 		cout << "日本鸭梨！" << endl;
    92. 	}
    93. };
    94.  
    95.  
    96. //抽象工厂 针对产品族
    97. class AbstractFactory {
    98. public:
    99. 	virtual AbstractApple* CreateApple() = 0;
    100. 	virtual AbstractBanana* CreateBanana() = 0;
    101. 	virtual AbstractPear* CreatePear() = 0;
    102. };
    103.  
    104. //中国工厂
    105. class ChinaFactory :public AbstractFactory {
    106. public:
    107. 	virtual AbstractApple* CreateApple() {
    108. 		return new ChinaApple;
    109. 	}
    110. 	virtual AbstractBanana* CreateBanana(){
    111. 		return new ChinaBanana;
    112. 	}
    113. 	virtual AbstractPear* CreatePear() {
    114. 		return new ChinaPear;
    115. 	}
    116. };
    117.  
    118. //美国工厂
    119. class USAFactory :public AbstractFactory {
    120. public:
    121. 	virtual AbstractApple* CreateApple() {
    122. 		return new USAApple;
    123. 	}
    124. 	virtual AbstractBanana* CreateBanana() {
    125. 		return new USABanan;
    126. 	}
    127. 	virtual AbstractPear* CreatePear() {
    128. 		return new  USAPear;
    129. 	}
    130. };
    131.  
    132. //日本工厂
    133. class JapanFactory :public AbstractFactory {
    134. public:
    135. 	virtual AbstractApple* CreateApple() {
    136. 		return new JapanApple;
    137. 	}
    138. 	virtual AbstractBanana* CreateBanana() {
    139. 		return new JapanBanan;
    140. 	}
    141. 	virtual AbstractPear* CreatePear() {
    142. 		return new  JapanPear;
    143. 	}
    144. };
    145.  
    146. int main() {
    147. 	AbstractFactory* factory = NULL;
    148. 	AbstractApple* apple = NULL;
    149. 	AbstractBanana* banana = NULL;
    150. 	AbstractPear* pear = NULL;
    151.  
    152. 	//中国工厂
    153. 	factory = new ChinaFactory;
    154. 	apple = factory->CreateApple();
    155. 	banana = factory->CreateBanana();
    156. 	pear = factory->CreatePear();
    157.  
    158. 	apple->ShowName();
    159. 	banana->ShowName();
    160. 	pear->ShowName();
    161. 	return 0;
    162. }

     四、单例模式

    只允许有一个类对象存在的一种模式

    类别描述

    适用场景
    • 系统只需要一个实例对象
    • 客户调用类的单个实例只允许使用一个公共访问点
    优点
    • 单例模式提供了对唯一实例的受控访问
    • 节约系统资源。由于在系统内存中只存在一个对象。
    缺点
    • 扩展略难
    • 单例类的职责过重
    • 1.懒汉式(需要的时候才会创建)
    • 2.饿汉式(直接静态创建，程序起来前就创建好了) -- 解决多线程问题
    1. #include 
    2. using namespace std;
    3.  
    4.  
    5. class A {
    6. private:
    7. 	A() {
    8. 		a = new A;
    9. 	}
    10. public:
    11. 	static A* getInstance() {
    12. 		return a;
    13. 	}
    14. private:
    15. 	static A* a;
    16. };
    17.  
    18.  
    19. A* A::a = NULL;
    20.  
    21. //实现单例步骤
    22. //1.构造函数私有化
    23. //2.增加静态私有的当前类的指针变量
    24. //3.提供静态对外接口，可以让用户获得单例对象
    25.  
    26. //单例 分为懒汉式 饿汉式
    27.  
    28. //1.懒汉式(需要的时候才会创建)
    29. class Singleton_lazy {
    30. private:
    31. 	Singleton_lazy() { cout << "我是懒汉构造！" << endl; }
    32. public:
    33. 	static Singleton_lazy* getInstance() {
    34. 		if (pSingleton == NULL) { /*此处判断有可能被强占执行*/
    35. 			pSingleton = new Singleton_lazy;
    36. 		}
    37. 		return pSingleton;
    38. 	}
    39. private:
    40. 	static Singleton_lazy* pSingleton;
    41. };
    42.  
    43. //类外初始化
    44. Singleton_lazy* Singleton_lazy::pSingleton = NULL;
    45.  
    46. //2.饿汉式
    47. class Singleton_hungry {
    48. private:
    49. 	Singleton_hungry() { cout << "我是饿汉构造！" << endl; }
    50. public:
    51. 	static Singleton_hungry* getInstance() {
    52. 		return pSingleton;
    53. 	}
    54. private:
    55. 	static Singleton_hungry* pSingleton;
    56. };
    57.  
    58. //类外初始化，此时已经创建对象完了
    59. Singleton_hungry* Singleton_hungry::pSingleton = new Singleton_hungry;
    60.  
    61.  
    62. int main() {
    63.  
    64. 	Singleton_lazy* p1 = Singleton_lazy::getInstance();
    65. 	Singleton_lazy* p2 = Singleton_lazy::getInstance();
    66. 	if (p1 == p2) {
    67. 		cout << "两个指针指向同一块内存空间，是单例！" << endl;
    68. 	}
    69. 	else {
    70. 		cout << "不是单例模式！" << endl;
    71. 	}
    72.  
    73. 	Singleton_hungry* p3 = Singleton_hungry::getInstance();
    74. 	Singleton_hungry* p4 = Singleton_hungry::getInstance();
    75. 	if (p3 == p4) {
    76. 		cout << "两个指针指向同一块内存空间，是单例！" << endl;
    77. 	}
    78. 	else {
    79. 		cout << "不是单例模式!" << endl;
    80. 	}
    81. 	cout << "main函数开始执行！" << endl;
    82.  
    83. 	return 0;
    84. }

  • 相关阅读:
    【Flink】第一节 源码编译
    linux网络协议栈源码分析 - 链路层ARP地址解析协议
    私域电商模式全解析：掌握这些方法，让你的生意不再难做！
    Halcon—3D测量算法的那点数学公式和代码实现
    服务注册发现_服务自保和服务剔除机制
    【PPT制作】基础篇
    Nginx原理以及基础知识详解
    图神经网络关系抽取论文阅读笔记（五）
    C# 学习之路（类型、存储和变量）
    AtCoder Beginner Contest 263 G.Erasing Prime Pairs(二分图最大匹配-网络流)
  • 原文地址：https://blog.csdn.net/AgingMoon/article/details/128171540