１時間で分かる GoF デザインパターン

TvFactory tvFactory = new SonyTvFactory();  // Sony 製の TV を作るための TvFactory
...
tvFactory.CreatePanel();  // SonyPanel を生成
tvFactory.CreateTuner();  // SonyTuner を生成
...

Product* Director::CreateProduct(Builder *builder) {
    builder->CreateStep1();
    builder->CreateStep2();
    builder->CreateStep3();
    return builder->GetProduct();
}

Component component = new TextComponent();  // 具象クラスが出るのはこの１回のみ
Renderer renderer = component.CreateRenderer();  // その後のインスタンス生成は抽象化される

// factory method の実装
Renderer TextComponent::CreateRenderer() {
    return new TextRenderer();  // このクラスに適したインスタンスを生成
}

PrototypeHoge hoge = prototypeHoge.Clone();

class Adapter : public Target {
private:
    Adaptee *m_pAdaptee;  // インタフェースの合わない既存のクラス

public:
    // object adapter の一般的な作り方
    Adapter(Adaptee *adaptee) : m_adaptee(adaptee) {}

    // クライアントは Target::DoSomething() の形で呼び出したい
    vitual void DoSomething() {
        m_adaptee->ProprietaryMethod();
        ...
    }
}

// 機能の階層 (Abstraction & RefinedAbstraction)
class Frame {
    void Draw() {
        Graphics *p = GetGraphics();
        p->DrawLine() で枠を描く
    }
}
class BeautifulFrame : public Frame {
    void Draw() {
        Graphics *p = GetGraphics();
        p->DrawLine() で綺麗な枠を描く
    }
}

// 内部実装の階層 (Implementor & ConcreteImplementor)
class Graphics {
    void DrawLine(Point, Point);
}
class BresenhamGraphics : public Graphics {
    void DrawLine(Point a, Point b) { Bresenham アルゴリズムによる線の描画 }
}
class EccentricGraphics : public Graphics {
    void DrawLine(Point a, Point b) { 変わったアルゴリズムによる線の描画 }
}

// File と Directory の共通の親クラス
class Entry {
public:
    virtual int GetSize();
};

class File : public Entry {
public:
    virtual int GetSize() { return 自分自身のサイズ; }
}

class Directory : public Entry {
public:
    virtual int GetSize() { return ディレクトリ内の合計サイズ; }
    void AddEntry(Entry *entry) { ディレクトリに追加; }
};

// Directory には File を格納できる
Directory *dir = new Directory();
dir->AddEntry(new File());
dir->AddEntry(new File());

// Directory に Directory を格納することもできる
Directory *dir2 = new Directory();
dir2->AddEntry(dir);

// Directory 内のファイルサイズ合計を取得
Print(dir2->GetSize());

// 拡張される側 (Component)
class Greeter {
public:
    virtual void Greet() = 0;
};

class OrdinaryGreeter : public Greeter {
public:
    virtual void Greet() { cout << "Hello. "; }
};

// 拡張する側 (Decorator)
class Decorator : public Greeter {
private:
    Greeter *m_greeter;
public:
    Decorator(Greeter *greeter) : m_greeter(greeter) {}
    virtual void Greet() { m_greeter->Greet(); }
    ...
};

class YahooDecorator : public Decorator {  // ConcreteDecorator
public:
    YahooDecorator(Greeter *greeter) : Decorator(greeter) {};
    virtual void Greet() {
        cout << "Yahoo! ";
        Decorator::Greet();
        cout << "WYYYRYYY!"
    }
};

// main
Greeter *greeter = new YahooDecorator(
                       new YahooDecorator(
                           new OrdinaryGreeter()));
greeter->Greet();  // "Yahoo! Hello. WYYYRYYY!"

class Facade {
private:
    static void DoEverything() {
        // 複数オブジェクトを駆使した処理をまとめる
        ClassA a;
        a.DoSomething();
        ClassB b;
        b.DoSomething(a);
        ClassC c;
        c.DoSomething(a, b);
    }
};

// main
Facade::DoEverything();  // クライアントはシンプルなインタフェースで呼び出すだけ

class Character {
private:
    char m_ch;    // 共有できる部分 (intrinsic state)
public:
    Character(char ch) : m_ch(ch) {}
    Draw(Position pos) { ... }    // 各々の Position は共有できない (extrinsic state)
};

class CharacterFactory {
private:
    Character m_char[MAX_CHAR];  // intrinsic state を持つオブジェクトはテーブルに入れて共有
public:
    static *Character CreateCharacter(char c) {
        if (m_characters[c]) {
            m_characters[c] = new Character(c);
        }
        return m_characters[c];
    }
};

// main
Character *pCh1 = CharacterFactory::GetCharacter('a');
Character *pCh2 = CharacterFactory::GetCharacter('a');  // 同じオブジェクトを参照する
pCh1->Draw(Position(0, 10));  // それぞれの描画位置は共有できないので引数で渡す
pCh2->Draw(Position(0, 20));

// (Subject) クライアントが使用するインタフェース
class Data {
    virtual void PrintData() = 0;
};

// (RealSubject) インスタンス化にコストがかかると仮定
class LargeData : public Data {
public:
    virtual void PrintData() { ... }
    ...
};

// (Proxy) RealSubject へのアクセスを制御（必要になってから RealSubject をインスタンス化）
class DataProxy : public Data {
private:
    LargeData *m_pData;
public:
    DataProxy() : m_pData(0) {}
    virtual void PrintData() {
        if (m_pData == 0) {
            m_pData = new LargeData();
        }
        m_pData->PrintData();
    }
    ...
}

// main
Data *pData = new DataProxy();  // この段階では LargeData はインスタンス化されない
pData->PrintData();  // この段階で Proxy 内部で LargeData が生成される

class Handler {
private:
    Handler *m_pSuccessor;  // 次のリクエスト転送先
public:
    Handler(Handler *pSuccessor = 0) : m_pSuccessor(pSuccessor) {}
    virtual void HandleRequest(const Request *pRequest) {
        if (m_pHandler) {
            m_pHandler->HandleRequest();
        }
    }
};

class ConcreteHandler1 : public Handler {
public:
    ConcreteHandler1(Handler *pSuccessor) : Handler(pSuccessor) {}
    virtual void HandleRequest(const Request *pRequest) {
        if (pRequest->GetType() == Request::SOME_KIND_OF_REQUEST) {
            // 自分の興味のあるリクエストだったら処理して終了
            cout << "Yahoooo!" << endl;
            return;
        }
        // 次の Handler へリクエストを転送
        Handler::HandleRequest();
    }
};

class ConcreteHandler2 : public Handler {
    ... 同様 ...
};

// main
Handler *pHandler = new ConcreteHandler1(new ConcreteHandler2(new CocreteHandler3());
pHandler->HandleRequest(someKindOfRequest);

class Command {
public:
    virtual ~Command();
    virtual void Execute() = 0;
};

class HelloCommand : public Command {
private:
    string m_name;
public:
    HelloCommand(string name) : m_name(name) {}
    virtual void Execute() { cout << "Hello " << name; }
};

class GoodByeCommand : public Command {
public:
    virtual void Execute() { cout << "Good bye"; }
};

// main
buttonA.SetCommand(new HelloCommand("Mike"));  // ボタン A が押された時の処理を設定
buttonB.SetCommand(new GoodByeCommand());  // ボタン B が押された時の処理を設定
timer.SetCommand(new GoodByeCommand(), 10);  // 10 分のタイマーが切れた時の処理を設定

class Expression {
public:
    virtual int Evaluate() = 0;
};

class Number : public Expression {
private:
    int m_num;
public:
    Number(int num) : m_num(num) {}
    virtual int Evaluate() { return m_num; }
};

class PlusExpression : public Expression {
public:
    PlusExpression(Expression *exp1, Expression *exp2) :
        m_exp1(exp1), m_exp2(exp2) {}

    // 足し算の解釈方法を定義（解釈方法は実装言語に依存した形で実装する）
    virtual int Evaluate() {
        return m_exp1.Evaluate() + m_exp2.Evaluate();
    }
};

// main
// "(100 + 200) + 300" を表現し、解釈する
Expression *pExp = new PlusExpression(
    new Expression(new Number(100), new Number(200)),
    new Number(300));
cout << pExp->Evaluate() << endl;    // 600

template<Item>
class ListIterator : public Iterator {  // List の要素を走査する Iterator
public:
    ListIterator(const List<Item> *pList) : m_pList(pList), m_index(0) {}
    virtual void First() { m_index = 0; }
    virtual void Next() { ++m_index; }
    virtual void bool IsDone() const { return m_index >= m_pList.Size(); }
    virtual Item CurrentItem() const { return m_pList.Item(m_index); }
private:
    const List<Item> *m_pList;
    int m_index;
};

// main
List<int> *pList = new List<int>;
pList->Add(100);
pList->Add(200);

ListIterator it(pList);
for (it->First(); !it->IsDone(); it->Next()) {
    cout << pList->CurrentItem() << endl;
}

class QuickEntryMediator : public ListBoxListener, public TextBoxListener {
public:
    QuickEntryMediator(ListBox *pListBox, TextBox *pTextBox) {
        : m_pListBox(pListBox), m_pTextBox(pTextBox) {
        m_pListBox.addListener(this);
        m_pTextBox.addListener(this);
    }
    virtual ~QuickEntryMediator() {
        m_pListBox.deleteListener(this);
        m_pTextBox.deleteListener(this);
    }

    // ListBox の選択が変更されたら、TextBox に内容を表示
    virtual void OnListBoxChanged(const Event& e) {
        m_pTextBox->SetText(m_pListBox->GetSelectedText());
    }

    // TextBox の内容が変更されたら、対応する ListBox の項目を選択
    virtual void OnTextBoxChanged(const Event& e) {
        int i = GetCorrespondingIndex(m_pTextBox.GetText());
        if (i > 0) {
            m_pListBox->Select(i);
        } else {
            m_pListBox->Unselect();
        }
    }

    int GetCorrespondingIndex(const string& text) { ... }
};

// Originator のある時点の状態（スナップショット）を保存
class Memento {
public:
    virtual ~Memento();
private:
    // Memento の内容は対象の Originator だけが設定／参照する
    friend class Originator;

    Memento();
    void GetState(State &state) { state = m_state; }
    void SetState(const State &state) { m_state = state; }
    State m_state;  // Originator の状態
};

class Originator {
public:
    Originator() { m_state.ChangeState(); }
    Mement CreateMemento();  // 現在のスナップショットを Memento オブジェクトに保存
    void SetMemento(const Memento& memento);  // 状態を Memento オブジェクトから復帰
    void ChangeState() { ... }

private:
    State m_state;
};

// main
Originator org;
org.ChangeState();
Mement mement = org.CreateMemento();  // 現在の状態を Memento オブジェクトに保存
org.ChangeState();
org.SetMemento(memento);  // 状態を復帰

class Subject {  // Subject interface
public:
    virtual ~Subject();
    virtual void *Attach(Observer *observer) {
        m_observers.Add(observer);
    }
    virtual void *Detach(Observer *observer) {
        m_observers.Remove(observer);
    }
    void Notify() {
        ListIterator it(m_observers);
        for (it.First(); !it.IsDone(); it.Next()) {
            it.CurrentItem()->Update(this);
        }
    }
protected:
    Subject();
    List m_observers;
}

class Observer {  // Observer interface
public:
    virtual ~Object();
    virtual void Update(Subject *changedSubject) = 0;
protected:
    Observer();
};

class Context {
public:
    Context() : m_pState(new ConcreteState1()) {}
    virtual Context() { delete m_pState; }
    void Request() {
        // 現在の状態に応じた処理を行う。中で状態が変化することもある。
        m_pState->Handle(this);
    }

private:
    friend class State;  // State オブジェクトにだけ ChangeState() を許可
    void ChangeState(State *pState) {
        delete m_pState;
        m_pState = pState;
    }
    State *m_pState;
};

class State {
public:
    virtual Handle(Context *pContext) = 0;
};

class ConcreteState1 : public State {
public:
    virtual Handle(Context *pContext) {
        cout << "state1" << endl;
        pContext->ChangeState(new ConcreteState2());
    }
};

class ConcreteState2 : public State {
public:
    virtual Handle(Context *pContext) {
        cout << "state2" << endl;
        pContext->ChangeState(new ConcreteState1());
    }
}

class TextBox {  // Strategy を利用するクラス
public:
    bool IsValid() {
        // このテキストボックスに入力された値が正しいかをチェック。
        // チェックの仕組み (Strategy) は自由に入れ換えられる。
        return m_pValidator->IsValid(GetText());
    }
    ...
private:
    Strategy *m_pValidator;
};

class Validator {  // テキストのフォーマットが正しいかを検証する Strategy
public:
    virtual bool IsValid(string text) = 0;
};

class PostalCodeValidator : public Validator {
public:
    virtual bool IsValid(string text) {
        ... text が郵便番号として正しいなら true を返す
    }
};

class AbstractClass {
public:
    // TemplateMethod 内でメソッドの呼び出し順序（アルゴリズム）が固定される
    void TemplateMethod() {
        PrimitiveOperation1();
        PrimitiveOperation2();
        ...
    }
protected:
    virtual void PrimitiveOperation1() = 0;
    virtual void PrimitiveOperation2() = 0;
};

class ConcreteClass : public AbstractClass {
protected:
    // TemplateMethod の中で呼ばれる各ステップの実装はサブクラスで定義できる
    virtual void PrimitiveOperation1() { ... }
    virtual void PrimitiveOperation2() { ... }
};

void ElementA::Accept(Visitor& visitor) {
    visitor.VisitElementA(this);  // 意味解釈は Visitor に任せる
}