C++のデザインパターンを使った条件分岐の最適化

#include <iostream>
#include <memory>

// Strategyインターフェース
class Strategy {
public:
    virtual void execute() const = 0;
};

// 具体的なStrategyクラス1
class ConcreteStrategyA : public Strategy {
public:
    void execute() const override {
        std::cout << "Strategy A executed." << std::endl;
    }
};

// 具体的なStrategyクラス2
class ConcreteStrategyB : public Strategy {
public:
    void execute() const override {
        std::cout << "Strategy B executed." << std::endl;
    }
};

// Contextクラス
class Context {
private:
    std::unique_ptr<Strategy> strategy;

public:
    void setStrategy(std::unique_ptr<Strategy> newStrategy) {
        strategy = std::move(newStrategy);
    }

    void executeStrategy() const {
        strategy->execute();
    }
};

int main() {
    Context context;

    context.setStrategy(std::make_unique<ConcreteStrategyA>());
    context.executeStrategy(); // Output: Strategy A executed.

    context.setStrategy(std::make_unique<ConcreteStrategyB>());
    context.executeStrategy(); // Output: Strategy B executed.

    return 0;
}

#include <iostream>
#include <memory>

// Stateインターフェース
class State {
public:
    virtual void handle() = 0;
};

// 具体的なStateクラス1
class ConcreteStateA : public State {
public:
    void handle() override {
        std::cout << "Handling state A." << std::endl;
    }
};

// 具体的なStateクラス2
class ConcreteStateB : public State {
public:
    void handle() override {
        std::cout << "Handling state B." << std::endl;
    }
};

// Contextクラス
class Context {
private:
    std::unique_ptr<State> state;

public:
    void setState(std::unique_ptr<State> newState) {
        state = std::move(newState);
    }

    void request() {
        state->handle();
    }
};

int main() {
    Context context;

    context.setState(std::make_unique<ConcreteStateA>());
    context.request(); // Output: Handling state A.

    context.setState(std::make_unique<ConcreteStateB>());
    context.request(); // Output: Handling state B.

    return 0;
}

#include <iostream>
#include <memory>

// Productインターフェース
class Product {
public:
    virtual void use() const = 0;
};

// 具体的なProductクラス1
class ConcreteProductA : public Product {
public:
    void use() const override {
        std::cout << "Using product A." << std::endl;
    }
};

// 具体的なProductクラス2
class ConcreteProductB : public Product {
public:
    void use() const override {
        std::cout << "Using product B." << std::endl;
    }
};

// Factoryクラス
class Factory {
public:
    enum class ProductType {
        ProductA,
        ProductB
    };

    static std::unique_ptr<Product> createProduct(ProductType type) {
        switch (type) {
            case ProductType::ProductA:
                return std::make_unique<ConcreteProductA>();
            case ProductType::ProductB:
                return std::make_unique<ConcreteProductB>();
            default:
                throw std::invalid_argument("Unknown product type");
        }
    }
};

int main() {
    auto productA = Factory::createProduct(Factory::ProductType::ProductA);
    productA->use(); // Output: Using product A.

    auto productB = Factory::createProduct(Factory::ProductType::ProductB);
    productB->use(); // Output: Using product B.

    return 0;
}

// Stateインターフェース
class PlayerState {
public:
    virtual void handleInput(Player& player, Input input) = 0;
    virtual void update(Player& player) = 0;
};

// 具体的なStateクラス（例: 歩行中、走行中）
class WalkingState : public PlayerState {
public:
    void handleInput(Player& player, Input input) override {
        if (input == Input::Run) {
            player.setState(std::make_unique<RunningState>());
        }
    }
    void update(Player& player) override {
        // 歩行中の更新処理
    }
};

class RunningState : public PlayerState {
public:
    void handleInput(Player& player, Input input) override {
        if (input == Input::Walk) {
            player.setState(std::make_unique<WalkingState>());
        }
    }
    void update(Player& player) override {
        // 走行中の更新処理
    }
};

// プレイヤークラス
class Player {
private:
    std::unique_ptr<PlayerState> state;

public:
    Player() : state(std::make_unique<WalkingState>()) {}

    void setState(std::unique_ptr<PlayerState> newState) {
        state = std::move(newState);
    }

    void handleInput(Input input) {
        state->handleInput(*this, input);
    }

    void update() {
        state->update(*this);
    }
};

// Strategyインターフェース
class PaymentStrategy {
public:
    virtual void pay(int amount) const = 0;
};

// 具体的なStrategyクラス（例: クレジットカード、PayPal）
class CreditCardPayment : public PaymentStrategy {
public:
    void pay(int amount) const override {
        std::cout << "Paid " << amount << " using Credit Card." << std::endl;
    }
};

class PayPalPayment : public PaymentStrategy {
public:
    void pay(int amount) const override {
        std::cout << "Paid " << amount << " using PayPal." << std::endl;
    }
};

// Contextクラス
class ShoppingCart {
private:
    std::unique_ptr<PaymentStrategy> paymentStrategy;

public:
    void setPaymentStrategy(std::unique_ptr<PaymentStrategy> newStrategy) {
        paymentStrategy = std::move(newStrategy);
    }

    void checkout(int amount) const {
        paymentStrategy->pay(amount);
    }
};

int main() {
    ShoppingCart cart;

    cart.setPaymentStrategy(std::make_unique<CreditCardPayment>());
    cart.checkout(100); // Output: Paid 100 using Credit Card.

    cart.setPaymentStrategy(std::make_unique<PayPalPayment>());
    cart.checkout(200); // Output: Paid 200 using PayPal.

    return 0;
}