기술나눔

23가지 디자인 패턴

2024-07-12

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

간단한 팩토리 패턴

간단한 공장 모드는 주로 인터페이스 선택 문제를 해결합니다.
Factory의 핵심 부분은 모든 제품을 생성하는 내부 논리를 구현하는 역할을 담당합니다. Factory 클래스는 필요한 객체를 생성하기 위해 외부 세계에서 직접 호출될 수 있습니다.

  1. // SingletonPattern.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
  2. //
  3. #include <iostream>
  4. using namespace std;
  5. //抽象汽车
  6. class AbstractCar
  7. {
  8. public:
  9. virtual void ShowCarName() = 0;
  10. };
  11. //具体产品的汽车继承->抽象汽车类,并且对他方法进行重写操作
  12. //凯美瑞
  13. class Camry :public AbstractCar
  14. {
  15. virtual void ShowCarName()
  16. {
  17. cout << "Camry Car." << endl;
  18. }
  19. };
  20. //迈腾
  21. class Magotan :public AbstractCar
  22. {
  23. virtual void ShowCarName()
  24. {
  25. cout << "Magotan Car." << endl;
  26. }
  27. };
  28. //奥迪
  29. class Aodi :public AbstractCar
  30. {
  31. virtual void ShowCarName()
  32. {
  33. cout << "Aodi Car." << endl;
  34. }
  35. };
  36. //奔驰
  37. class Benz :public AbstractCar
  38. {
  39. virtual void ShowCarName()
  40. {
  41. cout << "Benz Car." << endl;
  42. }
  43. };
  44. //通过传递参数来确定需要生成汽车
  45. //汽车工厂
  46. class Carfactory
  47. {
  48. public:
  49. static AbstractCar* CreateCarFunc(string cname)
  50. {
  51. if (cname == "Camry")
  52. //具体生产细节....
  53. return new Camry;
  54. else if (cname == "Magotan")
  55. //具体生产细节....
  56. return new Magotan;
  57. else if (cname == "Aodi")
  58. //具体生产细节....
  59. return new Aodi;
  60. else if (cname == "Benz")
  61. //具体生产细节....
  62. return new Benz;
  63. else
  64. return nullptr;
  65. }
  66. };
  67. int main()
  68. {
  69. //创建工厂
  70. Carfactory* fty = new Carfactory;
  71. //创建汽车
  72. AbstractCar* car;
  73. //指定工厂需要创建的汽车
  74. car = fty->CreateCarFunc("Benz");
  75. car->ShowCarName();
  76. delete car;
  77. return 0;
  78. }

 

2 추상 팩토리 패턴

추상 팩토리 패턴(Abstract Factory Pattern)은 디자인 패턴 중 창의적인 패턴으로 제품군을 구성하는데 사용됩니다. 추상 팩토리는 모든 형태의 팩토리 패턴 중 가장 추상적이고 일반적인 형태입니다. 추상 팩토리는 여러 추상 역할이 있을 때 사용되는 팩토리 패턴을 나타냅니다. 추상 팩토리 패턴은 클라이언트에 인터페이스를 제공하여 클라이언트가 특정 제품을 지정하지 않고도 여러 제품군에서 제품 객체를 생성할 수 있도록 합니다. 팩토리 패턴의 각 양식은 특정 문제에 대한 솔루션입니다. 팩토리 방법은 여러 제품 시리즈 구조를 목표로 하는 반면, 추상 팩토리 패턴은 제품군 내의 여러 제품 시리즈를 포함하는 여러 제품군 구조를 목표로 합니다.

         구체적인 클래스를 지정하지 않고 일련의 상호 의존적인 개체를 생성하기 위한 인터페이스를 제공합니다. 해결의 주요 목적: 주로 인터페이스 문제의 선택을 해결합니다.

추상 팩토리 패턴에서 클라이언트는 더 이상 객체 생성에 대한 책임이 없으며 이 책임을 특정 팩토리 클래스에 맡깁니다. 따라서 클라이언트는 객체 호출에만 책임이 있으므로 각 클래스의 책임이 명확해집니다.

추상 팩토리 패턴에는 네 가지 역할이 있습니다.추상 팩토리 역할특정 공장 역할추상적인 제품 페르소나특정 제품 역할.

코드 예시

  1. #include <iostream>
  2. using namespace std;
  3. // 抽象西瓜
  4. class AbstractWatermelon {
  5. public:
  6. virtual void PrintName() = 0;
  7. AbstractWatermelon() {
  8. cout << "抽象西瓜构造函数." << endl;
  9. }
  10. ~AbstractWatermelon() {
  11. cout << "抽象西瓜析构函数." << endl;
  12. }
  13. };
  14. // 抽象桔子
  15. class AbstractOrange {
  16. public:
  17. virtual void PrintName() = 0;
  18. AbstractOrange() {
  19. cout << "抽象桔子构造函数." << endl;
  20. }
  21. ~AbstractOrange() {
  22. cout << "抽象桔子析构函数." << endl;
  23. }
  24. };
  25. // 中国西瓜
  26. class ChinaWatermelon :public AbstractWatermelon {
  27. public:
  28. virtual void PrintName() {
  29. cout << "中国西瓜最好吃." << endl;
  30. }
  31. ChinaWatermelon() {
  32. cout << "中国西瓜构造函数." << endl;
  33. }
  34. ~ChinaWatermelon() {
  35. cout << "中国西瓜析构函数." << endl;
  36. }
  37. };
  38. // 中国桔子
  39. class ChinaOrange :public AbstractOrange
  40. {
  41. public:
  42. virtual void PrintName() {
  43. cout << "中国桔子最甜的.n" << endl;
  44. }
  45. ChinaOrange() {
  46. cout << "中国桔子构造函数." << endl;
  47. }
  48. ~ChinaOrange() {
  49. cout << "中国桔子析构函数" << endl;
  50. }
  51. };
  52. // 埃及西瓜
  53. class EgyptWatermelon :public AbstractWatermelon {
  54. public:
  55. virtual void PrintName() {
  56. cout << "埃及西瓜:早在四千年前就种植西瓜." << endl;
  57. }
  58. EgyptWatermelon() {
  59. cout << "埃及西瓜构造函数." << endl;
  60. }
  61. ~EgyptWatermelon() {
  62. cout << "埃及西瓜析构函数." << endl;
  63. }
  64. };
  65. // 埃及桔子
  66. class EgyptOrange :public AbstractOrange {
  67. public:
  68. virtual void PrintName() {
  69. cout << "埃及桔子光照条件最好,供应高质量的桔子.n" << endl;
  70. }
  71. EgyptOrange() {
  72. cout << "埃及桔子构造函数." << endl;
  73. }
  74. ~EgyptOrange() {
  75. cout << "埃及桔子析构函数." << endl;
  76. }
  77. };
  78. // 抽象工厂 主要针对产品转换
  79. class AbstrctFactory {
  80. public:
  81. virtual AbstractWatermelon* CreateWatermelon() = 0;
  82. virtual AbstractOrange* CreateOrange() = 0;
  83. AbstrctFactory() {
  84. cout << "抽象工厂构造函数." << endl;
  85. }
  86. ~AbstrctFactory() {
  87. cout << "抽象工厂析构函数." << endl;
  88. }
  89. };
  90. // 中国工厂
  91. class ChinaFactory :public AbstrctFactory
  92. {
  93. public:
  94. virtual AbstractWatermelon* CreateWatermelon() {
  95. return new ChinaWatermelon;
  96. }
  97. virtual AbstractOrange* CreateOrange() {
  98. return new ChinaOrange;
  99. }
  100. ChinaFactory() {
  101. cout << "中国工厂构造函数." << endl;
  102. }
  103. ~ChinaFactory() {
  104. cout << "中国工厂析构函数." << endl;
  105. }
  106. };
  107. // 埃及工厂
  108. class EgyptFactory :public AbstrctFactory {
  109. public:
  110. virtual AbstractWatermelon* CreateWatermelon() {
  111. return new EgyptWatermelon;
  112. }
  113. virtual AbstractOrange* CreateOrange() {
  114. return new EgyptOrange;
  115. }
  116. EgyptFactory() {
  117. cout << "埃及工厂构造函数." << endl;
  118. }
  119. ~EgyptFactory() {
  120. cout << "埃及工厂析构函数." << endl;
  121. }
  122. };
  123. int main()
  124. {
  125. cout << "****************************************************************************" << endl;
  126. //抽象工厂基类指针派生类对象
  127. AbstrctFactory* cfactory = new ChinaFactory;
  128. /*
  129. 抽象工厂构造函数.
  130. 中国工厂构造函数.
  131. */
  132. //抽象西瓜基类指针
  133. AbstractWatermelon* cwatermelon = cfactory->CreateWatermelon();
  134. /*
  135. 抽象西瓜构造函数.
  136. 中国西瓜构造函数.
  137. */
  138. AbstractOrange* corange = cfactory->CreateOrange();
  139. /*
  140. 抽象桔子构造函数.
  141. 中国桔子构造函数.
  142. */
  143. cwatermelon->PrintName();
  144. /*
  145. 中国西瓜最好吃.
  146. */
  147. corange->PrintName();
  148. /*
  149. 中国桔子最甜的.
  150. */
  151. delete corange; corange = nullptr;
  152. //抽象桔子析构函数.
  153. delete cwatermelon; cwatermelon = nullptr;
  154. //抽象西瓜析构函数.
  155. delete cfactory; cfactory = nullptr;
  156. //抽象工厂析构函数.
  157. cout << "****************************************************************************" << endl;
  158. cout << "nn****************************************************************************" << endl;
  159. AbstrctFactory* efactory = new EgyptFactory;
  160. /*
  161. 抽象工厂构造函数.
  162. 埃及工厂构造函数
  163. */
  164. AbstractWatermelon* ewatermelon = efactory->CreateWatermelon();
  165. /*
  166. 抽象西瓜构造函数
  167. 埃及西瓜构造函数.
  168. */
  169. AbstractOrange* eorange = efactory->CreateOrange();
  170. /*
  171. 抽象橘子构造函数
  172. 埃及橘子构造函数.
  173. */
  174. ewatermelon->PrintName();
  175. /*
  176. 埃及西瓜:早在四千年前就种植西瓜.
  177. */
  178. eorange->PrintName();
  179. /*
  180. 埃及桔子光照条件最好,供应高质量的桔子.
  181. */
  182. delete eorange; eorange = nullptr;//抽象桔子析构函数.
  183. delete ewatermelon; ewatermelon = nullptr;//抽象西瓜析构函数.
  184. delete efactory; efactory = nullptr;
  185. /*
  186. 抽象工厂析构函数.
  187. */
  188. cout << "****************************************************************************" << endl;
  189. return 0;
  190. }