現場で本当に使うGoFデザインパターンまとめ

#include <iostream>
#include <string>

// ロガークラスをSingletonとして定義
class Logger {
private:
    // 唯一のインスタンスへのポインタ
    static Logger* instance;

    // 外からnewできないようにコンストラクタをprivateにする
    Logger() {}

public:
    // コピーコンストラクタと代入演算子を禁止
    Logger(const Logger&) = delete;
    Logger& operator=(const Logger&) = delete;

    // インスタンス取得メソッド(グローバルアクセスポイント)
    static Logger* getInstance() {
        if (instance == nullptr) {
            instance = new Logger();
        }
        return instance;
    }

    // ログ出力メソッド
    void log(const std::string& message) {
        std::cout << "[LOG] " << message << std::endl;
    }
};

// 静的メンバ変数の定義
Logger* Logger::instance = nullptr;

int main() {
    // どこから呼んでも同じインスタンスが返される
    Logger* logger1 = Logger::getInstance();
    Logger* logger2 = Logger::getInstance();

    logger1->log("アプリケーション開始");
    logger2->log("同じインスタンスからログを出力");

    // ポインタが同じであることを確認
    if (logger1 == logger2) {
        std::cout << "logger1とlogger2は同じインスタンスです" << std::endl;
    }

    return 0;
}

// 製品インターフェース
interface Message {
    String getContent();
}

// 具体的な製品A
class HelloMessage implements Message {
    public String getContent() {
        return "Hello!";
    }
}

// 具体的な製品B
class ByeMessage implements Message {
    public String getContent() {
        return "Good bye!";
    }
}

// Creator(生成側の抽象クラス)
abstract class MessageCreator {
    // Factory Method: 具体的に何を作るかはサブクラスに任せる
    protected abstract Message createMessage();

    // 共通の処理フロー
    public void print() {
        Message msg = createMessage();
        System.out.println(msg.getContent());
    }
}

// 具体Creatorその1
class HelloMessageCreator extends MessageCreator {
    protected Message createMessage() {
        return new HelloMessage();
    }
}

// 具体Creatorその2
class ByeMessageCreator extends MessageCreator {
    protected Message createMessage() {
        return new ByeMessage();
    }
}

public class Main {
    public static void main(String[] args) {
        MessageCreator helloCreator = new HelloMessageCreator();
        MessageCreator byeCreator = new ByeMessageCreator();

        helloCreator.print(); // Hello!
        byeCreator.print();   // Good bye!
    }
}

#include <iostream>
#include <memory>

// 戦略インターフェース
class DiscountStrategy {
public:
    virtual ~DiscountStrategy() = default;
    // 金額を受け取り、割引後の金額を返す
    virtual int apply(int price) const = 0;
};

// 具体戦略A: 定率割引(10%OFF)
class PercentageDiscount : public DiscountStrategy {
public:
    int apply(int price) const override {
        return static_cast<int>(price * 0.9); // 10%割引
    }
};

// 具体戦略B: 定額割引(500円OFF)
class FixedDiscount : public DiscountStrategy {
public:
    int apply(int price) const override {
        int discounted = price - 500;
        return discounted > 0 ? discounted : 0;
    }
};

// Context: 戦略を保持し、必要なときに呼び出す側
class PriceCalculator {
private:
    std::shared_ptr<DiscountStrategy> strategy;

public:
    // 戦略を差し替え可能にする
    void setStrategy(std::shared_ptr<DiscountStrategy> s) {
        strategy = s;
    }

    int calculate(int basePrice) const {
        if (!strategy) {
            // 戦略が設定されていない場合は割引なし
            return basePrice;
        }
        return strategy->apply(basePrice);
    }
};

int main() {
    PriceCalculator calculator;

    // プランA: 定率割引
    calculator.setStrategy(std::make_shared<PercentageDiscount>());
    std::cout << "定率割引後: " << calculator.calculate(3000) << "円" << std::endl;

    // プランB: 定額割引
    calculator.setStrategy(std::make_shared<FixedDiscount>());
    std::cout << "定額割引後: " << calculator.calculate(3000) << "円" << std::endl;

    // 割引なし
    calculator.setStrategy(nullptr);
    std::cout << "割引なし: " << calculator.calculate(3000) << "円" << std::endl;

    return 0;
}

// 抽象クラス: テンプレートメソッドを持つ
abstract class DataImporter {

    // テンプレートメソッド: 処理の流れ(骨格)を定義
    public final void execute() {
        open();
        readData();
        close();
    }

    // 共通の前処理・後処理(必要ならオーバーライド可)
    protected void open() {
        System.out.println("接続を開きます");
    }

    protected void close() {
        System.out.println("接続を閉じます");
    }

    // 具体的な読み込み処理はサブクラスに任せる
    protected abstract void readData();
}

// CSVインポート用のサブクラス
class CsvImporter extends DataImporter {
    @Override
    protected void readData() {
        System.out.println("CSVファイルからデータを読み込みます");
    }
}

// APIインポート用のサブクラス
class ApiImporter extends DataImporter {
    @Override
    protected void readData() {
        System.out.println("外部APIからデータを取得します");
    }
}

public class TemplateMethodSample {
    public static void main(String[] args) {
        DataImporter csv = new CsvImporter();
        DataImporter api = new ApiImporter();

        csv.execute();
        System.out.println("----");
        api.execute();
    }
}

#include <iostream>
#include <vector>
#include <string>
#include <memory>

// 前方宣言
class Observer;

// Subject(観察される側)
class Subject {
private:
    std::vector<std::weak_ptr<Observer>> observers;
    std::string state;

public:
    void attach(std::shared_ptr<Observer> obs) {
        observers.push_back(obs);
    }

    void setState(const std::string& s);

    const std::string& getState() const {
        return state;
    }

    void notify();
};

// Observer(観察する側)のインターフェース
class Observer {
public:
    virtual ~Observer() = default;
    virtual void update(Subject& subject) = 0;
};

// 具体的Observer A
class ConsoleObserver : public Observer {
public:
    void update(Subject& subject) override {
        std::cout << "ConsoleObserver: state = " << subject.getState() << std::endl;
    }
};

// 具体的Observer B
class LengthObserver : public Observer {
public:
    void update(Subject& subject) override {
        std::cout << "LengthObserver: length = " 
                  << subject.getState().size() << std::endl;
    }
};

// Subjectのメソッド実装
void Subject::setState(const std::string& s) {
    state = s;
    notify(); // 状態変更時に通知
}

void Subject::notify() {
    for (auto& weakObs : observers) {
        if (auto obs = weakObs.lock()) {
            obs->update(*this);
        }
    }
}

int main() {
    Subject subject;

    auto consoleObs = std::make_shared<ConsoleObserver>();
    auto lengthObs = std::make_shared<LengthObserver>();

    subject.attach(consoleObs);
    subject.attach(lengthObs);

    subject.setState("Hello");
    subject.setState("Observer Pattern");

    return 0;
}

// コンポーネントのインターフェース
interface Notifier {
    void send(String message);
}

// 基本の実装(メール通知)
class EmailNotifier implements Notifier {
    public void send(String message) {
        System.out.println("メール送信: " + message);
    }
}

// デコレータの抽象クラス
abstract class NotifierDecorator implements Notifier {
    protected Notifier wrappee; // ラップする対象

    public NotifierDecorator(Notifier notifier) {
        this.wrappee = notifier;
    }

    public void send(String message) {
        wrappee.send(message);
    }
}

// 具体的デコレータ1: SMSも送る
class SmsNotifier extends NotifierDecorator {
    public SmsNotifier(Notifier notifier) {
        super(notifier);
    }

    public void send(String message) {
        super.send(message); // もとの処理(メール)を実行
        System.out.println("SMS送信: " + message);
    }
}

// 具体的デコレータ2: Slackにも送る
class SlackNotifier extends NotifierDecorator {
    public SlackNotifier(Notifier notifier) {
        super(notifier);
    }

    public void send(String message) {
        super.send(message); // もとの処理を実行
        System.out.println("Slack送信: " + message);
    }
}

public class DecoratorSample {
    public static void main(String[] args) {
        // 基本はメールだけ
        Notifier notifier = new EmailNotifier();

        // メール + SMS
        notifier = new SmsNotifier(notifier);

        // メール + SMS + Slack
        notifier = new SlackNotifier(notifier);

        notifier.send("システム障害が発生しました");
    }
}

// 複雑なサブシステムA: 認証
class AuthService {
    public boolean authenticate(String user, String password) {
        System.out.println("ユーザ認証中...");
        return "user".equals(user) && "pass".equals(password);
    }
}

// 複雑なサブシステムB: 在庫チェック
class InventoryService {
    public boolean checkStock(String itemId) {
        System.out.println("在庫チェック中...");
        return true;
    }
}

// 複雑なサブシステムC: 決済
class PaymentService {
    public boolean pay(String user, int amount) {
        System.out.println("決済処理中...");
        return true;
    }
}

// Facade: 上記の複雑な処理をまとめる窓口
class OrderFacade {
    private AuthService auth = new AuthService();
    private InventoryService inventory = new InventoryService();
    private PaymentService payment = new PaymentService();

    public boolean placeOrder(String user, String password, String itemId, int amount) {
        if (!auth.authenticate(user, password)) {
            System.out.println("認証失敗");
            return false;
        }
        if (!inventory.checkStock(itemId)) {
            System.out.println("在庫不足");
            return false;
        }
        if (!payment.pay(user, amount)) {
            System.out.println("決済失敗");
            return false;
        }
        System.out.println("注文完了");
        return true;
    }
}

public class FacadeSample {
    public static void main(String[] args) {
        OrderFacade facade = new OrderFacade();
        facade.placeOrder("user", "pass", "ITEM-001", 1000);
    }
}

// Commandインターフェース
interface Command {
    void execute();
}

// Receiver: 実際の処理を行うクラス
class TextEditor {
    private StringBuilder text = new StringBuilder();

    public void append(String str) {
        text.append(str);
    }

    public void print() {
        System.out.println(text.toString());
    }
}

// 具体的Command: 文字列を追加する
class AppendCommand implements Command {
    private TextEditor editor;
    private String textToAppend;

    public AppendCommand(TextEditor editor, String textToAppend) {
        this.editor = editor;
        this.textToAppend = textToAppend;
    }

    public void execute() {
        editor.append(textToAppend);
    }
}

// Invoker: Commandを発行する側
class CommandInvoker {
    public void submit(Command command) {
        // 実際にはここでキューに積んだりログを残したりできる
        command.execute();
    }
}

public class CommandSample {
    public static void main(String[] args) {
        TextEditor editor = new TextEditor();
        CommandInvoker invoker = new CommandInvoker();

        invoker.submit(new AppendCommand(editor, "Hello "));
        invoker.submit(new AppendCommand(editor, "Command "));
        invoker.submit(new AppendCommand(editor, "Pattern"));

        editor.print();
    }
}