Приложение №1. Базовые классы

Лабораторная работа №2

Порождающие паттерны

Паттерн Builder

Содержание

1. Описание паттерна.. 2

2. Задание к лабораторной работе.. 8

3. Приложение №1. Базовые классы... 9

 

Описание паттерна

 

Паттерн Builder

Название и классификация паттерна

Строитель - паттерн, порождающий объекты.

 

Применимость

Используйте паттерн строитель, когда:

• алгоритм создания сложного объекта не должен зависеть от того, из каких частей состоит объект и как они стыкуются между собой;
• процесс конструирования должен обеспечивать различные представления конструируемого объекта.

Структура

 

 

Участники

- Builder - строитель:

• задает абстрактный интерфейс для создания частей объекта Product;
• ConcreteBuilder - конкретный строитель: конструирует и собирает вместе части продукта посредством реализации интерфейса Builder; определяет создаваемое представление и следит за ним; предоставляет интерфейс для доступа к продукту;

- Director - распорядитель:

• - конструирует объект, пользуясь интерфейсом Builder;

- Product (ASCIIText, TeXText, TextWidget) - продукт:

• представляет сложный конструируемый объект. ConcreteBuilder строит внутреннее представление продукта и определяет процесс его сборки;
• включает классы, которые определяют составные части, в том числе интерфейсы для сборки конечного результата из частей.

 

Отношения

• клиент создает объект-распорядитель Director и конфигурирует его нужным объектом-строителем Builder;
• распорядитель уведомляет строителя о том, что нужно построить очередную часть продукта;
• строитель обрабатывает запросы распорядителя и добавляет новые части к продукту;
• клиент забирает продукт у строителя.

Следующая диаграмма взаимодействий иллюстрирует взаимоотношения строителя и распорядителя с клиентом.

 

 

 

 

Результаты

Плюсы и минусы паттерна строитель и его применения:

Ø позволяет изменять внутреннее представление продукта. Объект Builder предоставляет распорядителю абстрактный интерфейс для конструирования продукта, за которым он может скрыть представление и внутреннюю структуру продукта, а также процесс его сборки. Поскольку продукт конструируется через абстрактный интерфейс, то для изменения внутреннего представления достаточно всего лишь определить новый вид строителя;

Ø изолирует код, реализующий конструирование и представление. Паттерн строитель улучшает модульность, инкапсулируя способ конструирования и представления сложного объекта. Клиентам ничего не надо знать о классах, определяющих внутреннюю структуру продукта, они отсутствуют в интерфейсе строителя.

Реализация

 

Обычно существует абстрактный класс Builder, в котором определены операции для каждого компонента, который распорядитель может «попросить» создать.

По умолчанию эти операции ничего не делают. Но в классе конкретного строителя ConcreteBuilder они замещены для тех компонентов, в создании которых он принимает участие.

Пример кода

 

Определим вариант функции-члена CreateMaze, которая принимает в качестве аргумента строитель, принадлежащийклассу MazeBuilder.

Класс MazeBuilder определяет следующий интерфейс для построения лабиринтов:

 

 

 

class MazeBuilder {

public:

virtual void BuildMaze() { }

virtual void BuildRoom(int room) { }

virtual void BuildDoor(int roomFrom, int roomTo) { }

virtual Maze* GetMaze() { return 0; }

protected:

MazeBuilder();

};

 

Этот интерфейс позволяет создавать три вещи: лабиринт, комнату с конкретным номером, двери между пронумерованными комнатами. Операция GetMaze возвращает лабиринт клиенту. В подклассах MazeBuilder данная операция переопределяется для возврата реально созданного лабиринта.

Все операции построения лабиринта в классе MazeBuilder по умолчанию ничего не делают. Но они не объявлены исключительно виртуальными, чтобы в производных классах можно было замещать лишь часть методов.

Имея интерфейс MazeBuilder, можно изменить функцию-член CreateMaze, чтобы она принимала строитель в качестве параметра:

 

 

Maze* MazeGame::CreateMaze (MazeBuilder& builder) {

builder.BuildMaze();

builder.BuiIdRoom(l);

builder.BuiIdRoom(2);

builder.BuildDoor(1, 2);

return builder.GetMaze();

}

 

Обратите внимание, как строитель скрывает внутреннее представление лабиринта, то есть классы комнат, дверей и стен, и как эти части собираются вместе для завершения построения лабиринта. Кто-то, может, и догадается, что для представления комнат и дверей есть особые классы, но относительно стен нет даже намека. За счет этого становится проще модифицировать способ представления лабиринта, поскольку ни одного из клиентов MazeBuilder изменять не надо.

Как и другие порождающие паттерны, строитель инкапсулирует способ создания объектов; в данном случае с помощью интерфейса, определенного классом MazeBuilder. Это означает, что MazeBuilder можно повторно использовать для построения лабиринтов разных видов. В качестве примера приведем функцию GreateComplexMaze:

 

 

Maze* MazeGame::CreateComplexMaze (MazeBuilder& builder) {

builder.BuildRoom(l);

builder.BuildRoom(lOOl);

return builder.GetMaze(); }

 

 

Обратите внимание, что MazeBuilder не создает лабиринты самостоятельно, его основная цель - просто определить интерфейс для создания лабиринтов.

Пустые реализации в этом интерфейсе определены только для удобства. Реальную работу выполняют подклассы MazeBuilder.

Подкласс StandardMazeBuilder содержит реализацию построения простых лабиринтов. Чтобы следить за процессом создания, используется переменная _currentMaze:

 

 

class StandardMazeBuilder: public MazeBuilder {

public:

StandardMazeBuilder();

virtual void BuildMazeO;

virtual void BuildRoom(int);

virtual void BuildDoor(int, int);

virtual Maze* GetMazef();

private:

Direction CommonWall(Room*, Room*);

Maze* _currentMaze;

};

 

 

CommonWall (общая стена) - это вспомогательная операция, которая определяет направление общей для двух комнат стены.

Конструктор StandardMazeBuilder просто инициализирует _currentMaze:

 

 

StandardMazeBuilder::StandardMazeBuilder () {

_currentMaze = 0;

}

BuildMaze инстанцирует объект класса Maze, который будет собираться другими операциями и, в конце концов, возвратится клиенту (с помощью GetMaze):

 

 

void StandardMazeBuilder:: BuildMaze () {

_currentMaze = new Maze;

}

 

Maze* StandardMazeBuilder::GetMaze () {

return _currentMaze;

}

Операция BuildRoom создает комнату и строит вокруг нее стены:

 

 

void StandardMazeBuilder::BuildRoom (int n) {

if (!_currentMaze->RoomNo(n)) {

Room* room = new Room(n);

_currentMaze->AddRoom(room);

room->SetSide(North, new Wal l);

room->SetSide(South, new Wal l);

room->SetSide(East, new Wal l);

room->SetSide(West, new Wall);

}

}

 

 

Чтобы построить дверь между двумя комнатами, StandardMazeBuilder находит обе комнаты в лабиринте и их общую стену:

 

 

void StandardMazeBuilder: rBuildDoor (int nl, int n2) {

Room* rl = _currentMaze->RoomNo (nl);

Room* r2 = _currentMaze->RoomNo (n2);

Door* d = new Door(rl, r2);

rl->SetSide(CommonWall(rl,r2), d);

r2->SetSide(CommonWall(r2,rl), d);

}

 

 

Теперь для создания лабиринта клиенты могут использовать GreateMaze в сочетании с StandardMazeBuilder:

 

 

Maze* maze;

MazeGame game;

StandardMazeBuilder builder;

game. CreateMaze (builder);

maze = builder. GetMaze ();

 

 

Мы могли бы поместить все операции класса StandardMazeBuilder в класс Maze и позволить каждому лабиринту строить самого себя. Но чем меньше класс Maze, тем проще он для понимания и модификации, a StandardMazeBuilder легко отделяется от Maze. Еще важнее то, что разделение этих двух классов позволяет иметь множество разновидностей класса MazeBuilder, в каждом из которых есть собственные классы для комнат, дверей и стен.

Необычным вариантом MazeBuiIder является класс CountingMazeBuiIder.

Этот строитель вообще не создает никакого лабиринта, он лишь подсчитывает число компонентов разного вида, которые могли бы быть созданы:

 

 

 

class CountingMazeBuilder: public MazeBuilder {

public:

CountingMazeBuilder();

virtual void BuildMaze();

virtual void BuildRoom(int);

virtual void BuildDoor (int, int);

virtual void AddWall(int, Direction);

void GetCounts (int&, int&) const;

private:

int _doors,

int _rooms;

};

 

 

Конструктор инициализирует счетчики, а замещенные операции класса

MazeBuilder увеличивают их:

 

 

CountingMazeBuilder::CountingMazeBuilder () {

_rooms = _doors = 0;

}

void CountingMazeBuilder::BuildRoom (int) {

_rooms++;

}

void CountingMazeBuilder::BuildDoor (int, int) {

_doors++;

}

void CountingMazeBuilder::GetCounts (

int& rooms, int& doors

) const {

rooms = _rooms;

doors = _doors;

}

Вот как клиент мог бы использовать класс CountingMazeBuilder:

 

 

int rooms, doors;

MazeGame game;

CountingMazeBuilder builder;

game.CreateMaze(builder);

buiIder.GetCount s(rooms, doors);

cout «"В лабиринте есть "

«rooms «" комнат и "

«doors «" дверей" «endl;

 

 

 

Задание к лабораторной работе

 

1. Реализуйте программу, позволяющую построить простой лабиринт с помощью паттерна Builder;
2. Реализуйте класс CountingMazeBuilder подсчитывающий количесвто объектов (комнат и дверей) в лабиринте.
3. Опишите назначение функций-членов классов MazeBuiIder и CountingMazeBuilder.

 

Приложение №1. Базовые классы

 

Builder.C

 

 

#include "MazeParts.H"

#include "MazeGame.H"

#include <iostream.h>

 

class MazeBuilder {

public:

virtual void BuildMaze() { }

virtual void BuildRoom(int room) { }

virtual void BuildDoor(int roomFrom, int roomTo) { }

 

virtual Maze* GetMaze() { return 0; }

protected:

MazeBuilder();

};

 

Maze* MazeGame::CreateMaze (MazeBuilder& builder) {

builder.BuildMaze();

 

builder.BuildRoom(1);

builder.BuildRoom(2);

builder.BuildDoor(1, 2);

 

return builder.GetMaze();

}

 

Maze* MazeGame::CreateComplexMaze (MazeBuilder& builder) {

builder.BuildRoom(1);

//...

builder.BuildRoom(1001);

 

return builder.GetMaze();

}

 

class StandardMazeBuilder: public MazeBuilder {

public:

StandardMazeBuilder();

virtual void BuildMaze();

virtual void BuildRoom(int);

virtual void BuildDoor(int, int);

virtual Maze* GetMaze();

private:

Direction CommonWall(Room*, Room*);

Maze* _currentMaze;

};

 

StandardMazeBuilder::StandardMazeBuilder () {

_currentMaze = 0;

}

 

void StandardMazeBuilder::BuildMaze () {

_currentMaze = new Maze;

}

 

Maze *StandardMazeBuilder::GetMaze () {

Maze* maze = _currentMaze;

return maze;

}

 

void StandardMazeBuilder::BuildRoom (int n) {

if (!_currentMaze->RoomNo(n)) {

Room* room = new Room(n);

_currentMaze->AddRoom(room);

room->SetSide(North, new Wall);

room->SetSide(South, new Wall);

room->SetSide(East, new Wall);

room->SetSide(West, new Wall);

}

}

 

void StandardMazeBuilder::BuildDoor (int n1, int n2) {

Room* r1 = _currentMaze->RoomNo(n1);

Room* r2 = _currentMaze->RoomNo(n2);

Door* d = new Door(r1, r2);

r1->SetSide(CommonWall(r1,r2), d);

r2->SetSide(CommonWall(r2,r1), d);

}

 

void dummy() {

 

Maze* maze;

MazeGame game;

StandardMazeBuilder builder;

 

game.CreateMaze(builder);

maze = builder.GetMaze();

}

 

class CountingMazeBuilder: public MazeBuilder {

public:

CountingMazeBuilder();

 

virtual void BuildMaze();

virtual void BuildRoom(int);

virtual void BuildDoor(int, int);

virtual void AddWall(int, Direction);

void GetCounts(int&, int&) const;

private:

int _doors;

int _rooms;

};

CountingMazeBuilder::CountingMazeBuilder () {

_rooms = _doors = 0;

}

void CountingMazeBuilder::BuildRoom (int) {

_rooms++;

}

void CountingMazeBuilder::BuildDoor (int, int) {

_doors++;

}

void CountingMazeBuilder::GetCounts (

int& rooms, int& doors

) const {

rooms = _rooms;

doors = _doors;

}

void dummy1() {

int rooms, doors;

MazeGame game;

CountingMazeBuilder builder;

 

game.CreateMaze(builder);

builder.GetCounts(rooms, doors);

 

cout << "The maze has "

<< rooms << " rooms and "

<< doors << " doors" << endl;

}

 

 

 

MazeParts.H

 

 

#ifndef MazeParts_H

#define MazeParts_H

 

#include "defs.H"

 

enum Direction { North, East, South, West };

#ifndef MapSite_H

#define MapSite_H

 

class MapSite {

public:

virtual void Enter() = 0;

};

 

#endif

#ifndef _H

#define _H

 

class Room: public MapSite {

public:

Room(int = 0);

Room(const Room&);

 

virtual Room* Clone() const;

void InitializeRoomNo(int);

 

MapSite* GetSide(Direction);

void SetSide(Direction, MapSite*);

 

virtual void Enter();

private:

MapSite* _sides[4];

int _roomNumber;

};

#endif

#ifndef Wall_H

#define Wall_H

 

class Wall: public MapSite {

public:

 

Wall();

Wall(const Wall&);

virtual Wall* Clone() const;

virtual void Enter();

};

#endif

#ifndef Door_H

#define Door_H

 

class Door: public MapSite {

public:

Door(Room* = 0, Room* = 0);

Door(const Room&);

 

virtual Door* Clone() const;

void Initialize(Room*, Room*);

 

virtual void Enter();

Room* OtherSideFrom(Room*);

private:

Room* _room1;

Room* _room2;

bool _isOpen;

};

#endif

#ifndef Maze_H

#define Maze_H

 

class Maze {

public:

Maze();

Maze(const Maze&);

Room* RoomNo(int);

void AddRoom(Room*);

 

virtual Maze* Clone() const;

private:

//...

};

#endif

#ifndef BombedWall_H

#define BombedWall_H

 

class BombedWall: public Wall {

public:

BombedWall(bool bombed = false);

BombedWall(const BombedWall&);

 

virtual Wall* Clone() const;

void Intialize(bool);

 

virtual void Enter();

private:

bool _bomb;

};

#endif

#ifndef RoomWithABomb_H

#define RoomWithABomb_H

 

class RoomWithABomb: public Room {

public:

RoomWithABomb(int = 0, bool bombed = false);

RoomWithABomb(const RoomWithABomb&);

bool HasBomb();

private:

bool _bomb;

};

 

#endif

#ifndef EnchantedRoom_H

#define EnchantedRoom_H

 

class Spell;

 

class EnchantedRoom: public Room {

public:

EnchantedRoom(int, Spell* = 0);

EnchantedRoom(const EnchantedRoom&);

bool HasSpell();

Spell PickUpSpell();

private:

Spell* _spell;

};

 

#endif

#ifndef DoorNeedingSpell_H

#define DoorNeedingSpell_H

 

class DoorNeedingSpell: public Door {

public:

DoorNeedingSpell(Room*, Room*);

DoorNeedingSpell(const DoorNeedingSpell&);

bool TrySpell(Spell);

};

#endif

 

 

#endif

 

MazeGame.H

 

 

#ifndef MazeGame_H

#define MazeGame_H

 

class Maze;

class Wall;

class Door;

class Room;

 

class MazeFactory;

class MazeBuilder;

 

class MazeGame {

public:

Maze* CreateMaze();

 

Maze* CreateSimpleMaze();

Maze* CreateMaze(MazeFactory&);

Maze* CreateMaze(MazeBuilder&);

 

Maze* CreateComplexMaze (MazeBuilder& builder);

 

// factory methods

 

virtual Maze* MakeMaze() const;

virtual Room* MakeRoom(int n) const;

virtual Wall* MakeWall() const;

virtual Door* MakeDoor(Room* r1, Room* r2) const;

};

#endif