Wzorzec projektowy most - bridge

Stronę tą wyświetlono już: 1639 razy

Opis wzorca projektowego most

Wzorzec projektowy most należy do grupy wzorców strukturalnych. Umożliwia on oddzielenie interfejsu danych od interfejsu realizacji określonego zadania. Często też służy jako podział interfejsu układu sterującego od układu sterowanego (np. pilot - urządzenie). Ten wzorzec umożliwia stworzenie warstwy opisu ii oddzielnej warstwy realizacji np. pod różne platformy systemowe.

Przykładowy diagram UML wzorca projektowego most

Na poniższym diagramie UML pokazane zostało połączenie sterowania za pomocą pilota określonym urządzeniem. Istnieje tutaj interfejs iPilot, po którym dziedziczą klasy PilotLamp i PilotTV. To obiekty tych klas są tworzone przez programistę natomiast dostęp i operacje na nich są realizowane za pomocą interfejsu iPilot.

Interfejs iPilot agreguje interfejs iDevice w polu klasy device. Za interfejsem iDevice może stać jedna z dwóch klas: Lamp i TV. Te klasy odpowiadają za wykonanie sterowania a tworzenie ich instancji zostało zaszyte wewnątrz klas PilotLamp i PilotTV.

Przykładowy diagram UML wzorca projektowego most
Rys. 1
Przykładowy diagram UML wzorca projektowego most.

Przykładowa implementacja wzorca projektowego most

Listing 1
  1. #include <iostream>
  2. #include <string>
  4. class iDevice{
  5. public:
  6. virtual void on() = 0;
  7. virtual void off() = 0;
  8. };
  10. class Lamp : public iDevice{
  11. public:
  12. virtual void on(){
  13. std::cout << "Lamp state: (on)" << std::endl << std::endl;
  14. }
  16. virtual void off(){
  17. std::cout << "Lamp state: (off)" << std::endl << std::endl;
  18. }
  19. };
  21. class TV : public iDevice{
  22. public:
  23. virtual void on(){
  24. std::cout << "TV state: (on)" << std::endl << std::endl;
  25. }
  27. virtual void off(){
  28. std::cout << "TV state: (off)" << std::endl << std::endl;
  29. }
  30. };
  32. class iPilot{
  33. protected:
  34. iDevice *device;
  35. public:
  36. virtual void on() = 0;
  37. virtual void off() = 0;
  39. inline iPilot() : device(NULL){}
  40. virtual ~iPilot() {
  41. if(device){
  42. delete device;
  43. device = NULL;
  44. }
  45. }
  46. };
  48. class PilotTV : public iPilot{
  49. bool onOff;
  50. public:
  51. PilotTV() : onOff(false){
  52. device = new TV;
  53. }
  55. virtual void on(){
  56. if(!onOff){
  57. std::cout << "Turn on your God, turn on TV" << std::endl;
  58. onOff = true;
  59. if(device)
  60. device->on();
  61. }else{
  62. std::cout << "Your TV God is turned on already!!!" << std::endl << std::endl;
  63. }
  64. }
  65. virtual void off(){
  66. if(onOff){
  67. std::cout << "Turn off your God, turn off TV" << std::endl;
  68. onOff = false;
  69. if(device)
  70. device->off();
  71. }else{
  72. std::cout << "Your God is turned off already!!!" << std::endl << std::endl;
  73. }
  74. }
  76. virtual ~PilotTV(){
  77. std::cout << "Kill your God, kill your TV!!!" << std::endl << std::endl;
  78. }
  79. };
  81. class PilotLamp : public iPilot{
  82. bool onOff;
  83. public:
  84. PilotLamp() : onOff(false){
  85. device = new Lamp;
  86. }
  88. virtual void on(){
  89. if(!onOff){
  90. std::cout<<"Turn on your light, turn on Lamp" << std::endl;
  91. onOff = true;
  92. if(device)
  93. device->on();
  94. }else{
  95. std::cout<<"Your Lamp is turned on already!!!" << std::endl << std::endl;
  96. }
  97. }
  98. virtual void off(){
  99. if(onOff){
  100. std::cout<<"Turn off your light, turn off Lamp" << std::endl;
  101. onOff = false;
  102. if(device)
  103. device->off();
  104. }else{
  105. std::cout<<"Your Lamp is turned off already!!!" << std::endl << std::endl;
  106. }
  107. }
  109. virtual ~PilotLamp(){
  110. std::cout << "Kill your light, kill your Lamp!!!" << std::endl << std::endl;
  111. }
  112. };
  114. int main(){
  115. iPilot* tvPilot = new PilotTV;
  117. tvPilot->on();
  118. tvPilot->off();
  119. tvPilot->off();
  121. iPilot* lampPilot = new PilotLamp();
  123. lampPilot->on();
  124. lampPilot->on();
  125. lampPilot->off();
  127. std::cout<<"Cleaning memory mess" << std::endl << std::endl;
  129. if(tvPilot){
  130. delete tvPilot;
  131. tvPilot = 0;
  132. }
  134. if(lampPilot){
  135. delete lampPilot;
  136. lampPilot = NULL;
  137. }
  139. std::cin.get();
  140. return 0;
  141. }

Wynik działania powyższego kodu:

Turn on your God, turn on TV
TV state: (on)

Turn off your God, turn off TV
TV state: (off)

Your God is turned off already!!!

Turn on your light, turn on Lamp
Lamp state: (on)

Your Lamp is turned on already!!!

Turn off your light, turn off Lamp
Lamp state: (off)

Cleaning memory mess

Kill your God, kill your TV!!!

Kill your light, kill your Lamp!!!
Strony powiązane
strony powiązane
  1. sourcemaking.com/design_patterns/composite - strona opisująca wzorzec projektowy kompozyt [En]
  2. pl.wikipedia.org - opis tego wzorca na stronie Wikipedii

Komentarze