Design Patterns : Elements of Reusable Object-Oriented Software


Design Patterns: Elements of Reusable Object-Oriented Software



Download 4,06 Mb.
Pdf ko'rish
bet76/288
Sana07.04.2022
Hajmi4,06 Mb.
#535140
1   ...   72   73   74   75   76   77   78   79   ...   288
Bog'liq
GOF Design Patterns

Design Patterns: Elements of Reusable Object-Oriented Software 
97 
class Maze { 
public: 
Maze(); 
void AddRoom(Room*); 
Room* RoomNo(int) const; 
private: 
// ... 
}; 
RoomNo could do a look-up using a linear search, a hash table,or even a simple 
array. But we won't worry about such details here.Instead, we'll focus on how 
to specify the components of a maze object. 
Another class we define is MazeGame, which creates the maze.One straightforward 
way to create a maze is with a series of operationsthat add components to a maze 
and then interconnect them. Forexample, the following member function will create 
a maze consistingof two rooms with a door between them: 
Maze* MazeGame::CreateMaze () { 
Maze* aMaze = new Maze; 
Room* r1 = new Room(1); 
Room* r2 = new Room(2); 
Door* theDoor = new Door(r1, r2); 
aMaze->AddRoom(r1); 
aMaze->AddRoom(r2); 
r1->SetSide(North, new Wall); 
r1->SetSide(East, theDoor); 
r1->SetSide(South, new Wall); 
r1->SetSide(West, new Wall); 
r2->SetSide(North, new Wall); 
r2->SetSide(East, new Wall); 
r2->SetSide(South, new Wall); 
r2->SetSide(West, theDoor); 
return aMaze; 

This function is pretty complicated, considering that all it does is createa maze 
with two rooms. There are obvious ways to make it simpler. Forexample, the Room 
constructor could initialize the sideswith walls ahead of time. But that just 


Design Patterns: Elements of Reusable Object-Oriented Software 
98 
moves the code somewhere else.The real problem with this member function isn't 
its size but its 
inflexibility
. It hard-codes the maze layout. Changing the 
layoutmeans changing this member function, either by overriding it

whichmeans 
reimplementing the whole thing

or by changing parts ofit

which is error-prone 
and doesn't promote reuse. 
The creational patterns show how to make this design more 
flexible
, not necessarily 
smaller. In particular, they will make iteasy to change the classes that define 
the components of a maze. 
Suppose you wanted to reuse an existing maze layout for a new gamecontaining (of 
all things) enchanted mazes. The enchanted maze game hasnew kinds of components, 
like DoorNeedingSpell, a door thatcan be locked and opened subsequently only with 
a spell; andEnchantedRoom, a room that can have unconventional items init, like 
magic keys or spells. How can you change CreateMazeeasily so that it creates mazes 
with these new classes of objects? 
In this case, the biggest barrier to change lies in hard-coding theclasses that 
get instantiated. The creational patterns providedifferent ways to remove explicit 
references to concrete classesfrom code that needs to instantiate them: 

If CreateMaze calls virtual functions instead of constructorcalls to create 
the rooms, walls, and doors it requires, then you canchange the classes 
that get instantiated by making a subclass ofMazeGame and redefining those 
virtual functions. This approachis an example of the Factory Method (121) 
pattern. 

If CreateMaze is passed an object as a parameter to use tocreate rooms, 
walls, and doors, then you can change the classes ofrooms, walls, and doors 
by passing a different parameter. This is anexample of the Abstract Factory 
(99) pattern. 

If CreateMaze is passed an object that can create a new mazein its entirety 
using operations for adding rooms, doors, and walls tothe maze it builds, 
then you can use inheritance to change parts ofthe maze or the way the maze 
is built. This is an example of the Builder (110) pattern. 

If CreateMaze is parameterized by various prototypical room,door, and wall 
objects, which it then copies and adds to the maze,then you can change the 
maze's composition by replacing theseprototypical objects with different 
ones. This is an example of the Prototype (133) pattern. 
The remaining creational pattern, Singleton (144), canensure there's only one 
maze per game and that all game objects haveready access to it

without resorting 
to global variables orfunctions. Singleton also makes it easy to extend or replace 
the mazewithout touching existing code. 



Download 4,06 Mb.

Do'stlaringiz bilan baham:
1   ...   72   73   74   75   76   77   78   79   ...   288




Ma'lumotlar bazasi mualliflik huquqi bilan himoyalangan ©hozir.org 2024
ma'muriyatiga murojaat qiling

kiriting | ro'yxatdan o'tish
    Bosh sahifa
юртда тантана
Боғда битган
Бугун юртда
Эшитганлар жилманглар
Эшитмадим деманглар
битган бодомлар
Yangiariq tumani
qitish marakazi
Raqamli texnologiyalar
ilishida muhokamadan
tasdiqqa tavsiya
tavsiya etilgan
iqtisodiyot kafedrasi
steiermarkischen landesregierung
asarlaringizni yuboring
o'zingizning asarlaringizni
Iltimos faqat
faqat o'zingizning
steierm rkischen
landesregierung fachabteilung
rkischen landesregierung
hamshira loyihasi
loyihasi mavsum
faolyatining oqibatlari
asosiy adabiyotlar
fakulteti ahborot
ahborot havfsizligi
havfsizligi kafedrasi
fanidan bo’yicha
fakulteti iqtisodiyot
boshqaruv fakulteti
chiqarishda boshqaruv
ishlab chiqarishda
iqtisodiyot fakultet
multiservis tarmoqlari
fanidan asosiy
Uzbek fanidan
mavzulari potok
asosidagi multiservis
'aliyyil a'ziym
billahil 'aliyyil
illaa billahil
quvvata illaa
falah' deganida
Kompyuter savodxonligi
bo’yicha mustaqil
'alal falah'
Hayya 'alal
'alas soloh
Hayya 'alas
mavsum boyicha


yuklab olish