야 솔직히 말하자면... 디자인 패턴 처음 들었을 때 "이게 뭔 소리야?" 했던 사람 나만 아니지? 😅
근데 막상 공부하고 나면 "아 이거 없이 어떻게 코딩했지?" 싶어지는 그 느낌... 오늘 그 느낌 제대로 전달해볼게.
Gang of Four(GoF)가 1994년에 정리한 23가지 디자인 패턴, C++로 어떻게 구현하고 어디에 쓰는지 완전 파헤쳐보자고! 🔥

생성 패턴은 객체를 어떻게 만들지에 대한 고민을 해결해줘.
"그냥 new 쓰면 되는 거 아냐?" 라고 생각할 수 있는데... 그게 문제의 시작이거든 ㅋㅋㅋ
객체 생성 로직이 여기저기 퍼지면 나중에 수정할 때 지옥을 맛보게 됨. 그래서 생성 패턴이 필요한 거야!

C++에서 Singleton 구현할 때 멀티스레드 환경 고려 안 하면 진짜 큰일남 😱
C++11부터는 Meyers' Singleton이 가장 안전하고 깔끔한 방법으로 인정받고 있어!

// ✅ Meyers' Singleton - C++11 이후 가장 안전한 방법
#include <iostream>
#include <string>

class Logger {
public:
    // 정적 메서드로 유일한 인스턴스 반환
    static Logger& getInstance() {
        static Logger instance; // C++11: 스레드 안전 보장!
        return instance;
    }
    
    void log(const std::string& message) {
        std::cout << "[LOG] " << message << std::endl;
    }
    
    // 복사 생성자와 대입 연산자 삭제 (인스턴스 복사 방지)
    Logger(const Logger&) = delete;
    Logger& operator=(const Logger&) = delete;

private:
    Logger() { 
        std::cout << "Logger 초기화 완료!" << std::endl; 
    }
    ~Logger() = default;
};

int main() {
    Logger& logger1 = Logger::getInstance();
    Logger& logger2 = Logger::getInstance();
    
    logger1.log("첫 번째 로그 메시지");
    logger2.log("두 번째 로그 메시지");
    
    // 같은 인스턴스인지 확인
    std::cout << "같은 인스턴스? " 
              << (&logger1 == &logger2 ? "YES ✅" : "NO ❌") 
              << std::endl;
    return 0;
}

// 🏭 Factory Method 패턴 예제 - 게임 캐릭터 생성
#include <iostream>
#include <memory>
#include <string>

// 추상 제품 (Product)
class Character {
public:
    virtual ~Character() = default;
    virtual void attack() = 0;
    virtual std::string getName() const = 0;
};

// 구체 제품들 (Concrete Products)
class Warrior : public Character {
public:
    void attack() override {
        std::cout << getName() << ": 검으로 강타! ⚔️" << std::endl;
    }
    std::string getName() const override { return "전사"; }
};

class Mage : public Character {
public:
    void attack() override {
        std::cout << getName() << ": 파이어볼 발사! 🔥" << std::endl;
    }
    std::string getName() const override { return "마법사"; }
};

class Archer : public Character {
public:
    void attack() override {
        std::cout << getName() << ": 화살 발사! 🏹" << std::endl;
    }
    std::string getName() const override { return "궁수"; }
};

// 추상 생성자 (Creator)
class CharacterFactory {
public:
    virtual ~CharacterFactory() = default;
    // Factory Method - 서브클래스에서 구현
    virtual std::unique_ptr<Character> createCharacter() = 0;
    
    // 템플릿 메서드 - 생성 후 공통 처리
    void spawnCharacter() {
        auto character = createCharacter();
        std::cout << character->getName() << " 캐릭터 소환 완료! 🎮" << std::endl;
        character->attack();
    }
};

// 구체 생성자들 (Concrete Creators)
class WarriorFactory : public CharacterFactory {
public:
    std::unique_ptr<Character> createCharacter() override {
        return std::make_unique<Warrior>();
    }
};

class MageFactory : public CharacterFactory {
public:
    std::unique_ptr<Character> createCharacter() override {
        return std::make_unique<Mage>();
    }
};

int main() {
    WarriorFactory warriorFactory;
    MageFactory mageFactory;
    
    warriorFactory.spawnCharacter();
    mageFactory.spawnCharacter();
    
    return 0;
}

// 🎨 Abstract Factory - UI 테마 시스템
#include <iostream>
#include <memory>
#include <string>

// 추상 제품들
class Button {
public:
    virtual ~Button() = default;
    virtual void render() = 0;
};

class TextBox {
public:
    virtual ~TextBox() = default;
    virtual void render() = 0;
};

// 다크 테마 제품들
class DarkButton : public Button {
public:
    void render() override {
        std::cout << "🌑 [다크 버튼] 어두운 배경에 흰 텍스트" << std::endl;
    }
};

class DarkTextBox : public TextBox {
public:
    void render() override {
        std::cout << "🌑 [다크 텍스트박스] 어두운 입력창" << std::endl;
    }
};

// 라이트 테마 제품들
class LightButton : public Button {
public:
    void render() override {
        std::cout << "☀️ [라이트 버튼] 밝은 배경에 검은 텍스트" << std::endl;
    }
};

class LightTextBox : public TextBox {
public:
    void render() override {
        std::cout << "☀️ [라이트 텍스트박스] 밝은 입력창" << std::endl;
    }
};

// 추상 팩토리
class UIFactory {
public:
    virtual ~UIFactory() = default;
    virtual std::unique_ptr<Button> createButton() = 0;
    virtual std::unique_ptr<TextBox> createTextBox() = 0;
};

// 구체 팩토리들
class DarkThemeFactory : public UIFactory {
public:
    std::unique_ptr<Button> createButton() override {
        return std::make_unique<DarkButton>();
    }
    std::unique_ptr<TextBox> createTextBox() override {
        return std::make_unique<DarkTextBox>();
    }
};

class LightThemeFactory : public UIFactory {
public:
    std::unique_ptr<Button> createButton() override {
        return std::make_unique<LightButton>();
    }
    std::unique_ptr<TextBox> createTextBox() override {
        return std::make_unique<LightTextBox>();
    }
};

// 클라이언트 코드
void renderUI(UIFactory& factory) {
    auto button = factory.createButton();
    auto textBox = factory.createTextBox();
    button->render();
    textBox->render();
}

int main() {
    std::cout << "=== 다크 테마 ===" << std::endl;
    DarkThemeFactory darkFactory;
    renderUI(darkFactory);
    
    std::cout << "\n=== 라이트 테마 ===" << std::endl;
    LightThemeFactory lightFactory;
    renderUI(lightFactory);
    
    return 0;
}

// 🍔 Builder 패턴 - 버거 주문 시스템 (Fluent Interface)
#include <iostream>
#include <string>
#include <vector>

class Burger {
public:
    std::string bun;           // 번 종류
    std::string patty;         // 패티 종류
    bool cheese = false;       // 치즈 여부
    bool lettuce = false;      // 양상추 여부
    bool tomato = false;       // 토마토 여부
    std::string sauce;         // 소스
    int pattyCount = 1;        // 패티 개수
    
    void display() const {
        std::cout << "\n🍔 === 주문하신 버거 ===" << std::endl;
        std::cout << "번: " << bun << std::endl;
        std::cout << "패티: " << patty << " x" << pattyCount << std::endl;
        std::cout << "치즈: " << (cheese ? "✅" : "❌") << std::endl;
        std::cout << "양상추: " << (lettuce ? "✅" : "❌") << std::endl;
        std::cout << "토마토: " << (tomato ? "✅" : "❌") << std::endl;
        std::cout << "소스: " << sauce << std::endl;
        std::cout << "=====================" << std::endl;
    }
};

class BurgerBuilder {
private:
    Burger burger;
    
public:
    BurgerBuilder& setBun(const std::string& bun) {
        burger.bun = bun;
        return *this; // 메서드 체이닝을 위해 자기 자신 반환
    }
    
    BurgerBuilder& setPatty(const std::string& patty, int count = 1) {
        burger.patty = patty;
        burger.pattyCount = count;
        return *this;
    }
    
    BurgerBuilder& addCheese() {
        burger.cheese = true;
        return *this;
    }
    
    BurgerBuilder& addLettuce() {
        burger.lettuce = true;
        return *this;
    }
    
    BurgerBuilder& addTomato() {
        burger.tomato = true;
        return *this;
    }
    
    BurgerBuilder& setSauce(const std::string& sauce) {
        burger.sauce = sauce;
        return *this;
    }
    
    Burger build() {
        return burger; // 최종 객체 반환
    }
};

int main() {
    // Fluent Interface로 버거 주문 - 읽기 쉽고 직관적!
    Burger myBurger = BurgerBuilder()
        .setBun("통밀 번")
        .setPatty("소고기", 2)
        .addCheese()
        .addLettuce()
        .addTomato()
        .setSauce("특제 소스")
        .build();
    
    myBurger.display();
    
    // 간단한 버거도 쉽게!
    Burger simpleBurger = BurgerBuilder()
        .setBun("일반 번")
        .setPatty("닭고기")
        .setSauce("마요네즈")
        .build();
    
    simpleBurger.display();
    
    return 0;
}

// 🧬 Prototype 패턴 - 게임 몬스터 복제
#include <iostream>
#include <memory>
#include <string>

class Monster {
public:
    virtual ~Monster() = default;
    virtual std::unique_ptr<Monster> clone() const = 0; // 핵심!
    virtual void display() const = 0;
    
    std::string name;
    int hp;
    int attack;
};

class Goblin : public Monster {
public:
    Goblin(const std::string& n, int h, int a) {
        name = n; hp = h; attack = a;
    }
    
    // 복사 생성자 기반 clone
    std::unique_ptr<Monster> clone() const override {
        return std::make_unique<Goblin>(*this);
    }
    
    void display() const override {
        std::cout << "👺 " << name << " | HP:" << hp << " | ATK:" << attack << std::endl;
    }
};

class Dragon : public Monster {
public:
    Dragon(const std::string& n, int h, int a) {
        name = n; hp = h; attack = a;
    }
    
    std::unique_ptr<Monster> clone() const override {
        return std::make_unique<Dragon>(*this);
    }
    
    void display() const override {
        std::cout << "🐉 " << name << " | HP:" << hp << " | ATK:" << attack << std::endl;
    }
};

int main() {
    // 원본 몬스터 생성 (비용이 큰 작업이라고 가정)
    auto originalGoblin = std::make_unique<Goblin>("고블린 왕", 100, 25);
    
    // 복제로 빠르게 여러 몬스터 생성!
    auto goblin1 = originalGoblin->clone();
    auto goblin2 = originalGoblin->clone();
    
    // 복제된 몬스터 커스터마이징
    goblin1->name = "고블린 병사 A";
    goblin1->hp = 50;
    goblin2->name = "고블린 병사 B";
    goblin2->hp = 60;
    
    std::cout << "=== 몬스터 목록 ===" << std::endl;
    originalGoblin->display();
    goblin1->display();
    goblin2->display();
    
    return 0;
}

구조 패턴은 클래스와 객체를 어떻게 조합할지에 대한 해답을 줘.
레고 블록처럼 여러 클래스를 조합해서 더 큰 구조를 만드는 방법이라고 생각하면 됨! 🧱

// 🔌 Adapter 패턴 - 구형 결제 시스템 연동
#include <iostream>
#include <string>

// 새 시스템이 기대하는 인터페이스 (Target)
class PaymentProcessor {
public:
    virtual ~PaymentProcessor() = default;
    virtual void processPayment(const std::string& amount) = 0;
};

// 구형 결제 시스템 (Adaptee) - 변경 불가능한 레거시 코드
class LegacyPaymentSystem {
public:
    void makePayment(double amount, const std::string& currency) {
        std::cout << "💳 구형 시스템으로 결제: " 
                  << amount << " " << currency << std::endl;
    }
};

// 어댑터 - 구형 시스템을 새 인터페이스로 감쌈
class PaymentAdapter : public PaymentProcessor {
private:
    LegacyPaymentSystem legacySystem;
    
public:
    void processPayment(const std::string& amount) override {
        // 문자열 금액을 구형 시스템 형식으로 변환
        double numericAmount = std::stod(amount);
        legacySystem.makePayment(numericAmount, "KRW");
        std::cout << "✅ 어댑터를 통해 결제 완료!" << std::endl;
    }
};

// 클라이언트 코드 - 새 인터페이스만 알면 됨
void checkout(PaymentProcessor& processor, const std::string& amount) {
    std::cout << "결제 처리 중..." << std::endl;
    processor.processPayment(amount);
}

int main() {
    PaymentAdapter adapter;
    checkout(adapter, "50000");
    return 0;
}

// ☕ Decorator 패턴 - 커피 주문 시스템
#include <iostream>
#include <memory>
#include <string>

// 기본 컴포넌트 인터페이스
class Coffee {
public:
    virtual ~Coffee() = default;
    virtual std::string getDescription() const = 0;
    virtual double getCost() const = 0;
};

// 기본 커피 (Concrete Component)
class Espresso : public Coffee {
public:
    std::string getDescription() const override {
        return "에스프레소";
    }
    double getCost() const override { return 2000.0; }
};

class Americano : public Coffee {
public:
    std::string getDescription() const override {
        return "아메리카노";
    }
    double getCost() const override { return 3000.0; }
};

// 데코레이터 기본 클래스
class CoffeeDecorator : public Coffee {
protected:
    std::unique_ptr<Coffee> coffee;
    
public:
    CoffeeDecorator(std::unique_ptr<Coffee> c) : coffee(std::move(c)) {}
};

// 구체 데코레이터들
class MilkDecorator : public CoffeeDecorator {
public:
    MilkDecorator(std::unique_ptr<Coffee> c) 
        : CoffeeDecorator(std::move(c)) {}
    
    std::string getDescription() const override {
        return coffee->getDescription() + " + 우유🥛";
    }
    double getCost() const override {
        return coffee->getCost() + 500.0;
    }
};

class SyrupDecorator : public CoffeeDecorator {
private:
    std::string syrupType;
public:
    SyrupDecorator(std::unique_ptr<Coffee> c, const std::string& syrup) 
        : CoffeeDecorator(std::move(c)), syrupType(syrup) {}
    
    std::string getDescription() const override {
        return coffee->getDescription() + " + " + syrupType + "시럽🍯";
    }
    double getCost() const override {
        return coffee->getCost() + 700.0;
    }
};

class WhipDecorator : public CoffeeDecorator {
public:
    WhipDecorator(std::unique_ptr<Coffee> c) 
        : CoffeeDecorator(std::move(c)) {}
    
    std::string getDescription() const override {
        return coffee->getDescription() + " + 휘핑크림🍦";
    }
    double getCost() const override {
        return coffee->getCost() + 800.0;
    }
};

int main() {
    // 아메리카노 + 우유 + 바닐라시럽 + 휘핑크림
    std::unique_ptr<Coffee> myOrder = std::make_unique<Americano>();
    myOrder = std::make_unique<MilkDecorator>(std::move(myOrder));
    myOrder = std::make_unique<SyrupDecorator>(std::move(myOrder), "바닐라");
    myOrder = std::make_unique<WhipDecorator>(std::move(myOrder));
    
    std::cout << "☕ 주문: " << myOrder->getDescription() << std::endl;
    std::cout << "💰 가격: " << myOrder->getCost() << "원" << std::endl;
    
    return 0;
}

// 🏠 Facade 패턴 - 홈시어터 시스템
#include <iostream>

// 복잡한 서브시스템들
class Projector {
public:
    void on() { std::cout << "📽️ 프로젝터 켜짐" << std::endl; }
    void setInput(const std::string& input) { 
        std::cout << "📽️ 입력: " << input << std::endl; 
    }
    void off() { std::cout << "📽️ 프로젝터 꺼짐" << std::endl; }
};

class SoundSystem {
public:
    void on() { std::cout << "🔊 사운드 시스템 켜짐" << std::endl; }
    void setVolume(int vol) { 
        std::cout << "🔊 볼륨: " << vol << std::endl; 
    }
    void setSurroundMode() { 
        std::cout << "🔊 서라운드 모드 활성화" << std::endl; 
    }
    void off() { std::cout << "🔊 사운드 시스템 꺼짐" << std::endl; }
};

class Lights {
public:
    void dim(int level) { 
        std::cout << "💡 조명 " << level << "% 밝기" << std::endl; 
    }
    void on() { std::cout << "💡 조명 켜짐" << std::endl; }
};

class StreamingService {
public:
    void connect() { std::cout << "🌐 스트리밍 서비스 연결" << std::endl; }
    void play(const std::string& movie) { 
        std::cout << "▶️ 재생: " << movie << std::endl; 
    }
    void stop() { std::cout << "⏹️ 재생 중지" << std::endl; }
};

// Facade - 복잡한 서브시스템을 단순하게!
class HomeTheaterFacade {
private:
    Projector projector;
    SoundSystem sound;
    Lights lights;
    StreamingService streaming;
    
public:
    // 영화 보기 - 복잡한 과정을 하나의 메서드로!
    void watchMovie(const std::string& movie) {
        std::cout << "\n🎬 === 영화 모드 시작 ===" << std::endl;
        lights.dim(20);
        projector.on();
        projector.setInput("HDMI");
        sound.on();
        sound.setSurroundMode();
        sound.setVolume(70);
        streaming.connect();
        streaming.play(movie);
        std::cout << "🍿 즐거운 영화 감상!" << std::endl;
    }
    
    // 영화 종료
    void endMovie() {
        std::cout << "\n🌙 === 영화 모드 종료 ===" << std::endl;
        streaming.stop();
        sound.off();
        projector.off();
        lights.on();
    }
};

int main() {
    HomeTheaterFacade theater;
    theater.watchMovie("인터스텔라");
    // ... 영화 감상 ...
    theater.endMovie();
    return 0;
}

// 🛡️ Proxy 패턴 - 이미지 지연 로딩 (Virtual Proxy)
#include <iostream>
#include <string>
#include <memory>

// 공통 인터페이스
class Image {
public:
    virtual ~Image() = default;
    virtual void display() = 0;
    virtual std::string getFilename() const = 0;
};

// 실제 객체 - 생성 비용이 큼
class RealImage : public Image {
private:
    std::string filename;
    
    void loadFromDisk() {
        std::cout << "💾 디스크에서 로딩: " << filename 
                  << " (시간 소요...)" << std::endl;
    }
    
public:
    RealImage(const std::string& file) : filename(file) {
        loadFromDisk(); // 생성 시 바로 로딩
    }
    
    void display() override {
        std::cout << "🖼️ 이미지 표시: " << filename << std::endl;
    }
    
    std::string getFilename() const override { return filename; }
};

// 프록시 - 실제 객체 생성을 지연시킴
class ImageProxy : public Image {
private:
    std::string filename;
    mutable std::unique_ptr<RealImage> realImage; // 실제 이미지 (지연 생성)
    
public:
    ImageProxy(const std::string& file) : filename(file) {
        std::cout << "📋 프록시 생성: " << filename << " (아직 로딩 안 함)" << std::endl;
    }
    
    void display() override {
        // 처음 display() 호출 시에만 실제 이미지 생성
        if (!realImage) {
            std::cout << "⏳ 필요할 때 로딩 시작..." << std::endl;
            realImage = std::make_unique<RealImage>(filename);
        }
        realImage->display();
    }
    
    std::string getFilename() const override { return filename; }
};

int main() {
    std::cout << "=== 이미지 목록 생성 ===" << std::endl;
    // 프록시는 즉시 생성되지만 실제 이미지는 아직 로딩 안 됨
    ImageProxy img1("photo1.jpg");
    ImageProxy img2("photo2.jpg");
    ImageProxy img3("photo3.jpg");
    
    std::cout << "\n=== 첫 번째 이미지만 표시 ===" << std::endl;
    img1.display(); // 이때 실제 로딩 발생
    
    std::cout << "\n=== 첫 번째 이미지 다시 표시 ===" << std::endl;
    img1.display(); // 이미 로딩됨, 바로 표시
    
    // img2, img3은 display() 안 불렀으니 로딩 안 됨 = 메모리 절약!
    
    return 0;
}

행동 패턴은 객체들이 어떻게 상호작용하고 책임을 분배할지에 대한 해답이야.
11가지로 가장 많은 패턴이 있는 카테고리! 그 중 가장 중요하고 자주 쓰이는 것들 위주로 파헤쳐볼게 🔥

// 👁️ Observer 패턴 - 주식 가격 알림 시스템
#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <functional>

// 옵저버 인터페이스
class StockObserver {
public:
    virtual ~StockObserver() = default;
    virtual void onPriceChanged(const std::string& stock, double price) = 0;
};

// 주제 (Subject) - 관찰 대상
class StockMarket {
private:
    std::vector<StockObserver*> observers;
    std::string stockName;
    double price;
    
public:
    StockMarket(const std::string& name, double initialPrice)
        : stockName(name), price(initialPrice) {}
    
    void addObserver(StockObserver* observer) {
        observers.push_back(observer);
        std::cout << "📋 옵저버 등록 완료" << std::endl;
    }
    
    void removeObserver(StockObserver* observer) {
        observers.erase(
            std::remove(observers.begin(), observers.end(), observer),
            observers.end()
        );
    }
    
    void setPrice(double newPrice) {
        price = newPrice;
        std::cout << "\n📈 " << stockName << " 가격 변동: " 
                  << newPrice << "원" << std::endl;
        notifyObservers(); // 모든 옵저버에게 알림!
    }
    
private:
    void notifyObservers() {
        for (auto* observer : observers) {
            observer->onPriceChanged(stockName, price);
        }
    }
};

// 구체 옵저버들
class InvestorAlert : public StockObserver {
private:
    std::string name;
    double targetPrice;
    
public:
    InvestorAlert(const std::string& n, double target)
        : name(n), targetPrice(target) {}
    
    void onPriceChanged(const std::string& stock, double price) override {
        if (price >= targetPrice) {
            std::cout << "🔔 [" << name << "] " << stock 
                      << " 목표가 달성! 현재가: " << price << "원" << std::endl;
        } else {
            std::cout << "📊 [" << name << "] " << stock 
                      << " 현재가: " << price << "원 (목표: " 
                      << targetPrice << "원)" << std::endl;
        }
    }
};

class StopLossAlert : public StockObserver {
private:
    double stopLossPrice;
    
public:
    StopLossAlert(double stopPrice) : stopLossPrice(stopPrice) {}
    
    void onPriceChanged(const std::string& stock, double price) override {
        if (price <= stopLossPrice) {
            std::cout << "🚨 [손절 알림] " << stock 
                      << " 손절가 도달! 즉시 매도 권고!" << std::endl;
        }
    }
};

int main() {
    StockMarket samsung("삼성전자", 70000);
    
    InvestorAlert investor1("김투자", 75000);
    InvestorAlert investor2("이주식", 80000);
    StopLossAlert stopLoss(65000);
    
    samsung.addObserver(&investor1);
    samsung.addObserver(&investor2);
    samsung.addObserver(&stopLoss);
    
    samsung.setPrice(72000);
    samsung.setPrice(76000);
    samsung.setPrice(64000); // 손절가 도달!
    
    return 0;
}

// 🎯 Strategy 패턴 - 정렬 전략 시스템
#include <iostream>
#include <vector>
#include <algorithm>
#include <functional>
#include <string>

// 전략 인터페이스
class SortStrategy {
public:
    virtual ~SortStrategy() = default;
    virtual void sort(std::vector<int>& data) = 0;
    virtual std::string getName() const = 0;
};

// 구체 전략들
class BubbleSortStrategy : public SortStrategy {
public:
    void sort(std::vector<int>& data) override {
        int n = data.size();
        for (int i = 0; i < n-1; i++) {
            for (int j = 0; j < n-i-1; j++) {
                if (data[j] > data[j+1]) {
                    std::swap(data[j], data[j+1]);
                }
            }
        }
    }
    std::string getName() const override { return "버블 정렬"; }
};

class QuickSortStrategy : public SortStrategy {
public:
    void sort(std::vector<int>& data) override {
        std::sort(data.begin(), data.end()); // 실제로는 퀵소트 구현
    }
    std::string getName() const override { return "퀵 정렬"; }
};

class ReverseSortStrategy : public SortStrategy {
public:
    void sort(std::vector<int>& data) override {
        std::sort(data.begin(), data.end(), std::greater<int>());
    }
    std::string getName() const override { return "역순 정렬"; }
};

// 컨텍스트 - 전략을 사용하는 클래스
class DataSorter {
private:
    std::unique_ptr<SortStrategy> strategy;
    
public:
    DataSorter(std::unique_ptr<SortStrategy> s) : strategy(std::move(s)) {}
    
    // 런타임에 전략 교체 가능!
    void setStrategy(std::unique_ptr<SortStrategy> s) {
        strategy = std::move(s);
    }
    
    void sortData(std::vector<int>& data) {
        std::cout << "🔄 " << strategy->getName() << " 사용 중..." << std::endl;
        strategy->sort(data);
        
        std::cout << "결과: ";
        for (int val : data) std::cout << val << " ";
        std::cout << std::endl;
    }
};

int main() {
    std::vector<int> data1 = {64, 34, 25, 12, 22, 11, 90};
    std::vector<int> data2 = data1;
    std::vector<int> data3 = data1;
    
    DataSorter sorter(std::make_unique<BubbleSortStrategy>());
    sorter.sortData(data1);
    
    // 전략 교체!
    sorter.setStrategy(std::make_unique<QuickSortStrategy>());
    sorter.sortData(data2);
    
    sorter.setStrategy(std::make_unique<ReverseSortStrategy>());
    sorter.sortData(data3);
    
    return 0;
}

// 📋 Command 패턴 - 텍스트 에디터 Undo/Redo
#include <iostream>
#include <string>
#include <stack>
#include <memory>

// 텍스트 에디터 (Receiver)
class TextEditor {
private:
    std::string text;
    
public:
    void insertText(const std::string& str, int pos) {
        text.insert(pos, str);
        std::cout << "✏️ 삽입 후: \"" << text << "\"" << std::endl;
    }
    
    void deleteText(int pos, int length) {
        text.erase(pos, length);
        std::cout << "🗑️ 삭제 후: \"" << text << "\"" << std::endl;
    }
    
    std::string getText() const { return text; }
};

// 커맨드 인터페이스
class Command {
public:
    virtual ~Command() = default;
    virtual void execute() = 0;
    virtual void undo() = 0;
};

// 구체 커맨드들
class InsertCommand : public Command {
private:
    TextEditor& editor;
    std::string text;
    int position;
    
public:
    InsertCommand(TextEditor& e, const std::string& t, int pos)
        : editor(e), text(t), position(pos) {}
    
    void execute() override {
        editor.insertText(text, position);
    }
    
    void undo() override {
        editor.deleteText(position, text.length());
        std::cout << "↩️ 삽입 취소" << std::endl;
    }
};

class DeleteCommand : public Command {
private:
    TextEditor& editor;
    std::string deletedText;
    int position;
    int length;
    
public:
    DeleteCommand(TextEditor& e, int pos, int len)
        : editor(e), position(pos), length(len) {
        deletedText = e.getText().substr(pos, len);
    }
    
    void execute() override {
        editor.deleteText(position, length);
    }
    
    void undo() override {
        editor.insertText(deletedText, position);
        std::cout << "↩️ 삭제 취소" << std::endl;
    }
};

// 커맨드 관리자 (Invoker)
class CommandManager {
private:
    std::stack<std::unique_ptr<Command>> history;
    
public:
    void executeCommand(std::unique_ptr<Command> cmd) {
        cmd->execute();
        history.push(std::move(cmd));
    }
    
    void undo() {
        if (!history.empty()) {
            history.top()->undo();
            history.pop();
        } else {
            std::cout << "⚠️ 취소할 작업이 없습니다." << std::endl;
        }
    }
};

int main() {
    TextEditor editor;
    CommandManager manager;
    
    std::cout << "=== 텍스트 편집 ===" << std::endl;
    manager.executeCommand(std::make_unique<InsertCommand>(editor, "Hello", 0));
    manager.executeCommand(std::make_unique<InsertCommand>(editor, " World", 5));
    manager.executeCommand(std::make_unique<InsertCommand>(editor, "!", 11));
    
    std::cout << "\n=== Undo 3번 ===" << std::endl;
    manager.undo();
    manager.undo();
    manager.undo();
    
    return 0;
}

// 🔄 Iterator 패턴 - 커스텀 컬렉션 이터레이터
#include <iostream>
#include <stdexcept>

// 이터레이터 인터페이스
template<typename T>
class Iterator {
public:
    virtual ~Iterator() = default;
    virtual bool hasNext() const = 0;
    virtual T next() = 0;
};

// 커스텀 배열 컬렉션
template<typename T>
class NumberCollection {
private:
    T* data;
    int size;
    int capacity;
    
public:
    NumberCollection(int cap) : size(0), capacity(cap) {
        data = new T[capacity];
    }
    
    ~NumberCollection() { delete[] data; }
    
    void add(T value) {
        if (size < capacity) data[size++] = value;
    }
    
    T get(int index) const { return data[index]; }
    int getSize() const { return size; }
    
    // 이터레이터 클래스 (내부 클래스)
    class NumberIterator : public Iterator<T> {
    private:
        const NumberCollection<T>& collection;
        int current = 0;
        
    public:
        NumberIterator(const NumberCollection<T>& c) : collection(c) {}
        
        bool hasNext() const override {
            return current < collection.getSize();
        }
        
        T next() override {
            if (!hasNext()) throw std::out_of_range("더 이상 요소 없음");
            return collection.get(current++);
        }
    };
    
    NumberIterator createIterator() const {
        return NumberIterator(*this);
    }
};

int main() {
    NumberCollection<int> numbers(10);
    numbers.add(10);
    numbers.add(20);
    numbers.add(30);
    numbers.add(40);
    numbers.add(50);
    
    auto it = numbers.createIterator();
    
    std::cout << "🔄 이터레이터로 순회: ";
    while (it.hasNext()) {
        std::cout << it.next() << " ";
    }
    std::cout << std::endl;
    
    return 0;
}

// 🎭 State 패턴 - 자판기 상태 관리
#include <iostream>
#include <memory>
#include <string>

class VendingMachine; // 전방 선언

// 상태 인터페이스
class State {
public:
    virtual ~State() = default;
    virtual void insertCoin(VendingMachine& machine) = 0;
    virtual void selectProduct(VendingMachine& machine) = 0;
    virtual void dispense(VendingMachine& machine) = 0;
    virtual std::string getStateName() const = 0;
};

// 자판기 (Context)
class VendingMachine {
private:
    std::unique_ptr<State> currentState;
    int stock;
    
public:
    VendingMachine(int initialStock);
    
    void setState(std::unique_ptr<State> state) {
        currentState = std::move(state);
        std::cout << "🔄 상태 변경: " << currentState->getStateName() << std::endl;
    }
    
    void insertCoin() { currentState->insertCoin(*this); }
    void selectProduct() { currentState->selectProduct(*this); }
    void dispense() { currentState->dispense(*this); }
    
    int getStock() const { return stock; }
    void decreaseStock() { stock--; }
};

// 구체 상태들
class IdleState : public State {
public:
    void insertCoin(VendingMachine& machine) override;
    void selectProduct(VendingMachine& machine) override {
        std::cout << "⚠️ 먼저 동전을 넣어주세요!" << std::endl;
    }
    void dispense(VendingMachine& machine) override {
        std::cout << "⚠️ 동전을 먼저 넣어주세요!" << std::endl;
    }
    std::string getStateName() const override { return "대기 상태"; }
};

class HasCoinState : public State {
public:
    void insertCoin(VendingMachine& machine) override {
        std::cout << "⚠️ 이미 동전이 들어있습니다!" << std::endl;
    }
    void selectProduct(VendingMachine& machine) override;
    void dispense(VendingMachine& machine) override {
        std::cout << "⚠️ 먼저 상품을 선택해주세요!" << std::endl;
    }
    std::string getStateName() const override { return "동전 투입 상태"; }
};

class DispensingState : public State {
public:
    void insertCoin(VendingMachine& machine) override {
        std::cout << "⚠️ 상품 배출 중입니다!" << std::endl;
    }
    void selectProduct(VendingMachine& machine) override {
        std::cout << "⚠️ 상품 배출 중입니다!" << std::endl;
    }
    void dispense(VendingMachine& machine) override;
    std::string getStateName() const override { return "배출 상태"; }
};

// 상태 전환 구현
void IdleState::insertCoin(VendingMachine& machine) {
    std::cout << "💰 동전 투입!" << std::endl;
    machine.setState(std::make_unique<HasCoinState>());
}

void HasCoinState::selectProduct(VendingMachine& machine) {
    std::cout << "🎯 상품 선택!" << std::endl;
    machine.setState(std::make_unique<DispensingState>());
}

void DispensingState::dispense(VendingMachine& machine) {
    if (machine.getStock() > 0) {
        machine.decreaseStock();
        std::cout << "🥤 상품 배출 완료!" << std::endl;
        machine.setState(std::make_unique<IdleState>());
    } else {
        std::cout << "❌ 재고 없음!" << std::endl;
        machine.setState(std::make_unique<IdleState>());
    }
}

VendingMachine::VendingMachine(int initialStock) : stock(initialStock) {
    currentState = std::make_unique<IdleState>();
    std::cout << "🏪 자판기 초기화 (재고: " << stock << "개)" << std::endl;
}

int main() {
    VendingMachine machine(3);
    
    std::cout << "\n=== 정상 구매 ===" << std::endl;
    machine.insertCoin();
    machine.selectProduct();
    machine.dispense();
    
    std::cout << "\n=== 잘못된 순서 ===" << std::endl;
    machine.selectProduct(); // 동전 없이 선택 시도
    machine.insertCoin();
    machine.insertCoin(); // 중복 투입 시도
    machine.selectProduct();
    machine.dispense();
    
    return 0;
}

// 📐 Template Method 패턴 - 음료 제조 프로세스
#include <iostream>
#include <string>

class BeverageMaker {
public:
    // 템플릿 메서드 - 알고리즘 골격 정의 (final로 오버라이드 방지)
    void makeBeverage() {
        boilWater();
        brew();          // 서브클래스에서 구현
        pourInCup();
        if (customerWantsCondiments()) { // 훅 메서드
            addCondiments(); // 서브클래스에서 구현
        }
        std::cout << "✅ " << getBeverageName() << " 완성!" << std::endl;
    }
    
    virtual ~BeverageMaker() = default;

protected:
    void boilWater() {
        std::cout << "💧 물 끓이는 중..." << std::endl;
    }
    
    void pourInCup() {
        std::cout << "☕ 컵에 따르는 중..." << std::endl;
    }
    
    // 서브클래스에서 반드시 구현해야 하는 추상 메서드
    virtual void brew() = 0;
    virtual void addCondiments() = 0;
    virtual std::string getBeverageName() const = 0;
    
    // 훅 메서드 - 선택적으로 오버라이드 가능
    virtual bool customerWantsCondiments() const { return true; }
};

class CoffeeMaker : public BeverageMaker {
protected:
    void brew() override {
        std::cout << "☕ 커피 원두 우려내는 중..." << std::endl;
    }
    
    void addCondiments() override {
        std::cout << "🥛 설탕과 우유 추가!" << std::endl;
    }
    
    std::string getBeverageName() const override { return "커피"; }
};

class TeaMaker : public BeverageMaker {
protected:
    void brew() override {
        std::cout << "🍵 차 우려내는 중..." << std::endl;
    }
    
    void addCondiments() override {
        std::cout << "🍋 레몬 추가!" << std::endl;
    }
    
    std::string getBeverageName() const override { return "차"; }
    
    // 훅 메서드 오버라이드 - 이 차는 첨가물 없이!
    bool customerWantsCondiments() const override { return false; }
};

int main() {
    std::cout << "=== 커피 만들기 ===" << std::endl;
    CoffeeMaker coffee;
    coffee.makeBeverage();
    
    std::cout << "\n=== 차 만들기 ===" << std::endl;
    TeaMaker tea;
    tea.makeBeverage();
    
    return 0;
}

C++11 이후로 언어 자체가 많이 발전하면서 디자인 패턴 구현 방식도 달라졌어!
std::function, 람다, std::unique_ptr, std::shared_ptr, 가변 템플릿 등을 활용하면
더 간결하고 안전한 패턴 구현이 가능해짐 😎

현대 C++에서 Strategy 패턴을 람다로 구현하면 이렇게 훨씬 간결해져!

// ⚡ 현대 C++ - 람다로 Strategy 패턴 구현
#include <iostream>
#include <functional>
#include <vector>
#include <algorithm>

class ModernSorter {
private:
    // std::function으로 전략 저장
    std::function<bool(int, int)> compareStrategy;
    
public:
    // 람다나 함수 포인터를 전략으로 받음
    ModernSorter(std::function<bool(int, int)> strategy) 
        : compareStrategy(strategy) {}
    
    void sort(std::vector<int>& data) {
        std::sort(data.begin(), data.end(), compareStrategy);
    }
};

// CRTP (Curiously Recurring Template Pattern) - 정적 다형성
template<typename Derived>
class CRTPBase {
public:
    void interface() {
        static_cast<Derived*>(this)->implementation();
    }
};

class CRTPDerived : public CRTPBase<CRTPDerived> {
public:
    void implementation() {
        std::cout << "🎯 CRTP: 가상함수 없이 다형성 구현!" << std::endl;
    }
};

int main() {
    std::vector<int> data = {5, 2, 8, 1, 9, 3};
    
    // 람다로 오름차순 전략
    ModernSorter ascSorter([](int a, int b) { return a < b; });
    ascSorter.sort(data);
    std::cout << "오름차순: ";
    for (int v : data) std::cout << v << " ";
    std::cout << std::endl;
    
    // 람다로 내림차순 전략
    ModernSorter descSorter([](int a, int b) { return a > b; });
    descSorter.sort(data);
    std::cout << "내림차순: ";
    for (int v : data) std::cout << v << " ";
    std::cout << std::endl;
    
    // CRTP 사용
    CRTPDerived obj;
    obj.interface();
    
    return 0;
}

패턴을 알았다고 다가 아니야! 언제 어떤 패턴을 써야 하는지가 진짜 실력이거든 ㅋㅋ
현업에서 자주 마주치는 상황별로 어떤 패턴을 선택해야 하는지 정리해봤어!

여기까지 GoF 23가지 패턴 중 핵심적인 것들을 C++로 구현해봤어!
마지막으로 디자인 패턴을 공부하면서 꼭 기억해야 할 것들 정리해줄게 😊

디자인 패턴은 처음엔 어렵게 느껴지지만, 하나씩 실제 코드에 적용해보면서 익히다 보면
어느 순간 "아, 이 상황에서는 이 패턴이네!" 하고 자연스럽게 떠오르게 돼.
그 순간이 오면 진짜 C++ 개발자로 한 단계 업그레이드된 거야! 🚀

꾸준히 코딩하고, 꾸준히 리팩토링하고, 꾸준히 성장하자! 화이팅! 💪