प्रौद्योगिकी साझेदारी

२३ डिजाइनप्रतिमानाः

2024-07-12

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

एकः सरलः कारखानाप्रतिमानः

सरलः कारखानाविधिः मुख्यतया अन्तरफलकचयनस्य समस्यायाः समाधानं करोति ।
कारखानस्य मूलभागः सर्वेषां उत्पादानाम् निर्माणस्य आन्तरिकतर्कस्य कार्यान्वयनस्य उत्तरदायी भवति आवश्यकवस्तूनि निर्मातुं बहिः जगति प्रत्यक्षतया कारखानावर्गः आह्वयितुं शक्यते।

  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. }

 

२ अमूर्त कारखाना प्रतिरूप

Abstract Factory Pattern इति डिजाइन-प्रतिमानयोः एकः रचनात्मकः प्रतिरूपः अस्ति, यस्य उपयोगः उत्पादपरिवारस्य निर्माणार्थं भवति । अमूर्तकारखाना कारखानाप्रतिमानानाम् सर्वेषां रूपेषु अमूर्ततमं सामान्यं च रूपम् अस्ति । अमूर्तकारखाना इति कारखानाप्रतिमानं निर्दिशति यदा बहुविधाः अमूर्तभूमिकाः सन्ति । अमूर्तकारखानाप्रतिमानं ग्राहकाय एकं अन्तरफलकं प्रदातुं शक्नोति, यत् ग्राहकं विशिष्टानि उत्पादानि निर्दिश्य बहुषु उत्पादपरिवारेषु उत्पादवस्तूनि निर्मातुं शक्नोति कारखाना-प्रतिरूपे प्रत्येकं रूपं एकस्याः निश्चितसमस्यायाः समाधानं भवति, यदा तु अमूर्त-कारखाना-प्रतिमानं बहु-उत्पाद-परिवार-संरचनानां लक्ष्यं भवति, यत्र उत्पाद-परिवारस्य अन्तः बहु-उत्पाद-श्रृङ्खला भवति

         परस्परनिर्भरवस्तूनाम् एकं श्रृङ्खलां निर्मातुं तेषां ठोसवर्गान् निर्दिश्य एकं अन्तरफलकं प्रदाति । समाधानस्य मुख्य उद्देश्यम् : मुख्यतया अन्तरफलकसमस्यानां चयनस्य समाधानम्।

अमूर्तकारखानाप्रतिरूपेण ग्राहकः वस्तुनिर्माणस्य उत्तरदायी न भवति, अपितु एतत् उत्तरदायित्वं विशिष्टकारखानवर्गाणां कृते त्यजति ग्राहकः केवलं वस्तुनां आह्वानस्य उत्तरदायी भवति, तस्मात् प्रत्येकस्य वर्गस्य उत्तरदायित्वं स्पष्टं भवति

अमूर्तकारखानप्रतिमानस्य चत्वारि भूमिकाः सन्ति- १.अमूर्त कारखाना भूमिकाविशिष्टाः कारखानाभूमिकाःअमूर्त उत्पाद personaविशिष्टानि उत्पादभूमिकाः।

कोड उदाहरणम्

  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. }