class Animal {
public:
    void makeSound() {
        cout << "동물 소리!" << endl;
    }
};

class Dog : public Animal {
public:
    void makeSound() {
        cout << "멍멍!" << endl;
    }
};

class Cat : public Animal {
public:
    void makeSound() {
        cout << "야옹!" << endl;
    }
};

Animal* animal = new Dog();
animal->makeSound();  // 결과: "동물 소리!" (어? 멍멍이 아니네?)

class Animal {
public:
    virtual void makeSound() {  // virtual 키워드 추가!
        cout << "동물 소리!" << endl;
    }
    
    virtual ~Animal() {}  // 가상 소멸자도 중요해!
};

class Dog : public Animal {
public:
    void makeSound() override {  // override 키워드로 명확하게!
        cout << "멍멍!" << endl;
    }
};

class Cat : public Animal {
public:
    void makeSound() override {
        cout << "야옹!" << endl;
    }
};

Animal* animal1 = new Dog();
Animal* animal2 = new Cat();

animal1->makeSound();  // 결과: "멍멍!" 🎉
animal2->makeSound();  // 결과: "야옹!" 🎊

delete animal1;
delete animal2;

🎓 가상함수 사용 시 주의사항

class Base {
public:
    virtual ~Base() {  // 이거 없으면 메모리 누수 발생!
        cout << "Base 소멸자" << endl;
    }
};

class Derived : public Base {
private:
    int* data;
public:
    Derived() { data = new int[100]; }
    ~Derived() {
        delete[] data;  // 이게 호출 안 되면 메모리 누수!
        cout << "Derived 소멸자" << endl;
    }
};

class Animal {
public:
    virtual void makeSound() const { }
};

class Dog : public Animal {
public:
    // 실수로 const를 빼먹었다면?
    void makeSound() override {  // 컴파일 에러 발생! 👍
        cout << "멍멍!" << endl;
    }
};

class Animal {
public:
    virtual void makeSound() { }
};

class Dog : public Animal {
public:
    void makeSound() final {  // 더 이상 오버라이드 불가!
        cout << "멍멍!" << endl;
    }
};

class Puppy : public Dog {
public:
    void makeSound() { }  // 컴파일 에러!
};

class Shape {
public:
    // = 0을 붙이면 순수 가상함수!
    virtual double getArea() const = 0;
    virtual void draw() const = 0;
    
    virtual ~Shape() {}
};

Shape shape;  // 컴파일 에러! 추상클래스는 인스턴스화 불가
Shape* ptr = new Shape();  // 이것도 에러!

class Circle : public Shape {
private:
    double radius;
    
public:
    Circle(double r) : radius(r) {}
    
    double getArea() const override {
        return 3.14159 * radius * radius;
    }
    
    void draw() const override {
        cout << "원을 그립니다. 반지름: " << radius << endl;
    }
};

class Rectangle : public Shape {
private:
    double width, height;
    
public:
    Rectangle(double w, double h) : width(w), height(h) {}
    
    double getArea() const override {
        return width * height;
    }
    
    void draw() const override {
        cout << "사각형을 그립니다. " << width << "x" << height << endl;
    }
};

vector<Shape*> shapes;
shapes.push_back(new Circle(5.0));
shapes.push_back(new Rectangle(4.0, 6.0));
shapes.push_back(new Circle(3.0));

for (Shape* shape : shapes) {
    shape->draw();
    cout << "면적: " << shape->getArea() << endl;
}

// 메모리 해제도 잊지 말자!
for (Shape* shape : shapes) {
    delete shape;
}
shapes.clear();

🎯 인터페이스 클래스 패턴

// 인터페이스 역할을 하는 추상클래스
class IDrawable {
public:
    virtual void draw() const = 0;
    virtual ~IDrawable() {}
};

class IPrintable {
public:
    virtual void print() const = 0;
    virtual ~IPrintable() {}
};

// 다중 상속으로 여러 인터페이스 구현
class Document : public IDrawable, public IPrintable {
private:
    string content;
    
public:
    Document(const string& c) : content(c) {}
    
    void draw() const override {
        cout << "문서를 화면에 표시합니다." << endl;
    }
    
    void print() const override {
        cout << "문서를 프린터로 출력합니다: " << content << endl;
    }
};

// 추상 기본 클래스
class GameCharacter {
protected:
    string name;
    int health;
    int attackPower;
    
public:
    GameCharacter(const string& n, int hp, int atk) 
        : name(n), health(hp), attackPower(atk) {}
    
    virtual ~GameCharacter() {}
    
    // 순수 가상함수들
    virtual void attack() = 0;
    virtual void defend() = 0;
    virtual void useSpecialSkill() = 0;
    
    // 일반 가상함수 (기본 구현 제공)
    virtual void takeDamage(int damage) {
        health -= damage;
        if (health < 0) health = 0;
        cout << name << "이(가) " << damage << " 데미지를 받았습니다! ";
        cout << "남은 체력: " << health << endl;
    }
    
    // 일반 멤버 함수
    bool isAlive() const { return health > 0; }
    string getName() const { return name; }
    int getHealth() const { return health; }
};

// 전사 클래스
class Warrior : public GameCharacter {
private:
    int armor;
    
public:
    Warrior(const string& n) 
        : GameCharacter(n, 150, 30), armor(20) {}
    
    void attack() override {
        cout << name << "이(가) 강력한 검 공격을 합니다! 💪" << endl;
        cout << "공격력: " << attackPower << endl;
    }
    
    void defend() override {
        cout << name << "이(가) 방패로 방어합니다! 🛡️" << endl;
        cout << "방어력: " << armor << endl;
    }
    
    void useSpecialSkill() override {
        cout << name << "의 특수 스킬: 광전사의 분노! ⚔️" << endl;
        cout << "공격력이 2배로 증가합니다!" << endl;
    }
    
    void takeDamage(int damage) override {
        int actualDamage = damage - armor;
        if (actualDamage < 0) actualDamage = 0;
        GameCharacter::takeDamage(actualDamage);
    }
};

// 마법사 클래스
class Mage : public GameCharacter {
private:
    int mana;
    
public:
    Mage(const string& n) 
        : GameCharacter(n, 80, 50), mana(100) {}
    
    void attack() override {
        if (mana >= 10) {
            cout << name << "이(가) 파이어볼을 시전합니다! 🔥" << endl;
            cout << "마법 공격력: " << attackPower << endl;
            mana -= 10;
        } else {
            cout << "마나가 부족합니다!" << endl;
        }
    }
    
    void defend() override {
        cout << name << "이(가) 마법 보호막을 생성합니다! ✨" << endl;
        mana -= 5;
    }
    
    void useSpecialSkill() override {
        if (mana >= 50) {
            cout << name << "의 특수 스킬: 메테오! ☄️" << endl;
            cout << "광역 마법 공격!" << endl;
            mana -= 50;
        } else {
            cout << "마나가 부족합니다!" << endl;
        }
    }
};

// 궁수 클래스
class Archer : public GameCharacter {
private:
    int arrows;
    
public:
    Archer(const string& n) 
        : GameCharacter(n, 100, 40), arrows(30) {}
    
    void attack() override {
        if (arrows > 0) {
            cout << name << "이(가) 화살을 발사합니다! 🏹" << endl;
            cout << "공격력: " << attackPower << endl;
            arrows--;
        } else {
            cout << "화살이 떨어졌습니다!" << endl;
        }
    }
    
    void defend() override {
        cout << name << "이(가) 재빠르게 회피합니다! 💨" << endl;
    }
    
    void useSpecialSkill() override {
        if (arrows >= 5) {
            cout << name << "의 특수 스킬: 연속 사격! 🎯" << endl;
            cout << "5발의 화살을 동시에 발사!" << endl;
            arrows -= 5;
        } else {
            cout << "화살이 부족합니다!" << endl;
        }
    }
};

int main() {
    // 다양한 캐릭터 생성
    vector<GameCharacter*> party;
    party.push_back(new Warrior("그롬"));
    party.push_back(new Mage("엘리나"));
    party.push_back(new Archer("레고라스"));
    
    cout << "=== 파티원 소개 ===" << endl;
    for (auto character : party) {
        cout << character->getName() << " (체력: " 
             << character->getHealth() << ")" << endl;
    }
    
    cout << "\n=== 전투 시작! ===" << endl;
    
    // 다형성의 힘! 같은 인터페이스로 다른 동작
    for (auto character : party) {
        character->attack();
        character->useSpecialSkill();
        cout << endl;
    }
    
    cout << "=== 적의 공격! ===" << endl;
    for (auto character : party) {
        character->takeDamage(25);
    }
    
    // 메모리 해제
    for (auto character : party) {
        delete character;
    }
    party.clear();
    
    return 0;
}

1️⃣ 팩토리 패턴 (Factory Pattern)

// 앞에서 만든 GameCharacter 클래스들을 활용
class CharacterFactory {
public:
    enum CharacterType {
        WARRIOR,
        MAGE,
        ARCHER
    };
    
    static GameCharacter* createCharacter(CharacterType type, const string& name) {
        switch(type) {
            case WARRIOR:
                return new Warrior(name);
            case MAGE:
                return new Mage(name);
            case ARCHER:
                return new Archer(name);
            default:
                return nullptr;
        }
    }
};

// 사용 예시
int main() {
    // 팩토리를 통해 객체 생성
    GameCharacter* char1 = CharacterFactory::createCharacter(
        CharacterFactory::WARRIOR, "아서스"
    );
    
    GameCharacter* char2 = CharacterFactory::createCharacter(
        CharacterFactory::MAGE, "제이나"
    );
    
    char1->attack();
    char2->attack();
    
    delete char1;
    delete char2;
    
    return 0;
}

2️⃣ 전략 패턴 (Strategy Pattern)

// 공격 전략 인터페이스
class AttackStrategy {
public:
    virtual ~AttackStrategy() {}
    virtual void execute() = 0;
};

// 구체적인 전략들
class MeleeAttack : public AttackStrategy {
public:
    void execute() override {
        cout << "근접 공격! 검으로 베기! ⚔️" << endl;
    }
};

class RangedAttack : public AttackStrategy {
public:
    void execute() override {
        cout << "원거리 공격! 화살 발사! 🏹" << endl;
    }
};

class MagicAttack : public AttackStrategy {
public:
    void execute() override {
        cout << "마법 공격! 파이어볼! 🔥" << endl;
    }
};

// 전략을 사용하는 캐릭터
class StrategicCharacter {
private:
    string name;
    AttackStrategy* strategy;
    
public:
    StrategicCharacter(const string& n) : name(n), strategy(nullptr) {}
    
    ~StrategicCharacter() {
        if (strategy) delete strategy;
    }
    
    void setAttackStrategy(AttackStrategy* newStrategy) {
        if (strategy) delete strategy;
        strategy = newStrategy;
    }
    
    void performAttack() {
        if (strategy) {
            cout << name << "의 공격: ";
            strategy->execute();
        } else {
            cout << "공격 전략이 설정되지 않았습니다!" << endl;
        }
    }
};

// 사용 예시
int main() {
    StrategicCharacter hero("용사");
    
    // 상황에 따라 전략 변경
    cout << "=== 1단계: 근접 전투 ===" << endl;
    hero.setAttackStrategy(new MeleeAttack());
    hero.performAttack();
    
    cout << "\n=== 2단계: 원거리 전투 ===" << endl;
    hero.setAttackStrategy(new RangedAttack());
    hero.performAttack();
    
    cout << "\n=== 3단계: 마법 전투 ===" << endl;
    hero.setAttackStrategy(new MagicAttack());
    hero.performAttack();
    
    return 0;
}

3️⃣ 옵저버 패턴 (Observer Pattern)

// 옵저버 인터페이스
class Observer {
public:
    virtual ~Observer() {}
    virtual void update(const string& message) = 0;
};

// 주체(Subject) 클래스
class Subject {
private:
    vector<Observer*> observers;
    string state;
    
public:
    void attach(Observer* observer) {
        observers.push_back(observer);
    }
    
    void detach(Observer* observer) {
        observers.erase(
            remove(observers.begin(), observers.end(), observer),
            observers.end()
        );
    }
    
    void notify() {
        for (Observer* observer : observers) {
            observer->update(state);
        }
    }
    
    void setState(const string& newState) {
        state = newState;
        cout << "상태 변경: " << state << endl;
        notify();  // 모든 옵저버에게 알림!
    }
    
    string getState() const { return state; }
};

// 구체적인 옵저버들
class Player : public Observer {
private:
    string name;
    
public:
    Player(const string& n) : name(n) {}
    
    void update(const string& message) override {
        cout << "[플레이어 " << name << "] 알림 받음: " 
             << message << " 🎮" << endl;
    }
};

class UIDisplay : public Observer {
public:
    void update(const string& message) override {
        cout << "[UI 디스플레이] 화면 업데이트: " 
             << message << " 🖥️" << endl;
    }
};

class SoundSystem : public Observer {
public:
    void update(const string& message) override {
        cout << "[사운드 시스템] 효과음 재생: " 
             << message << " 🔊" << endl;
    }
};

// 사용 예시
int main() {
    Subject gameState;
    
    Player player1("철수");
    Player player2("영희");
    UIDisplay ui;
    SoundSystem sound;
    
    // 옵저버 등록
    gameState.attach(&player1);
    gameState.attach(&player2);
    gameState.attach(&ui);
    gameState.attach(&sound);
    
    cout << "=== 게임 시작 ===" << endl;
    gameState.setState("게임 시작!");
    
    cout << "\n=== 적 출현 ===" << endl;
    gameState.setState("보스 등장!");
    
    cout << "\n=== 플레이어2 퇴장 ===" << endl;
    gameState.detach(&player2);
    gameState.setState("아이템 획득!");
    
    return 0;
}

4️⃣ 싱글톤 패턴 (Singleton Pattern)

class GameManager {
private:
    static GameManager* instance;
    int score;
    int level;
    
    // private 생성자로 외부 생성 차단!
    GameManager() : score(0), level(1) {
        cout << "게임 매니저 초기화" << endl;
    }
    
    // 복사 생성자와 대입 연산자 삭제
    GameManager(const GameManager&) = delete;
    GameManager& operator=(const GameManager&) = delete;
    
public:
    static GameManager* getInstance() {
        if (instance == nullptr) {
            instance = new GameManager();
        }
        return instance;
    }
    
    static void destroyInstance() {
        if (instance != nullptr) {
            delete instance;
            instance = nullptr;
        }
    }
    
    void addScore(int points) {
        score += points;
        cout << "점수 획득! 현재 점수: " << score << endl;
    }
    
    void levelUp() {
        level++;
        cout << "레벨 업! 현재 레벨: " << level << endl;
    }
    
    int getScore() const { return score; }
    int getLevel() const { return level; }
};

// static 멤버 초기화
GameManager* GameManager::instance = nullptr;

// 사용 예시
int main() {
    // 어디서든 같은 인스턴스 접근!
    GameManager* gm1 = GameManager::getInstance();
    gm1->addScore(100);
    
    GameManager* gm2 = GameManager::getInstance();
    gm2->levelUp();
    
    // gm1과 gm2는 같은 객체!
    cout << "gm1 점수: " << gm1->getScore() << endl;
    cout << "gm2 점수: " << gm2->getScore() << endl;
    
    GameManager::destroyInstance();
    return 0;
}

5️⃣ 템플릿 메서드 패턴 (Template Method Pattern)

class DataProcessor {
public:
    // 템플릿 메서드: 알고리즘의 골격
    void process() {
        loadData();
        validateData();
        processData();
        saveData();
        cleanup();
    }
    
    virtual ~DataProcessor() {}
    
protected:
    // 서브클래스에서 구현할 순수 가상함수들
    virtual void loadData() = 0;
    virtual void processData() = 0;
    virtual void saveData() = 0;
    
    // 기본 구현을 제공하는 가상함수
    virtual void validateData() {
        cout << "데이터 유효성 검사 중..." << endl;
    }
    
    virtual void cleanup() {
        cout << "정리 작업 완료" << endl;
    }
};

class CSVProcessor : public DataProcessor {
protected:
    void loadData() override {
        cout << "CSV 파일 로딩 중... 📄" << endl;
    }
    
    void processData() override {
        cout << "CSV 데이터 처리 중... ⚙️" << endl;
    }
    
    void saveData() override {
        cout << "CSV 파일로 저장 중... 💾" << endl;
    }
};

class JSONProcessor : public DataProcessor {
protected:
    void loadData() override {
        cout << "JSON 파일 로딩 중... 📋" << endl;
    }
    
    void processData() override {
        cout << "JSON 데이터 파싱 및 처리 중... ⚙️" << endl;
    }
    
    void saveData() override {
        cout << "JSON 파일로 저장 중... 💾" << endl;
    }
    
    // 유효성 검사를 오버라이드
    void validateData() override {
        cout << "JSON 스키마 검증 중... ✅" << endl;
    }
};

// 사용 예시
int main() {
    cout << "=== CSV 처리 ===" << endl;
    DataProcessor* csv = new CSVProcessor();
    csv->process();
    
    cout << "\n=== JSON 처리 ===" << endl;
    DataProcessor* json = new JSONProcessor();
    json->process();
    
    delete csv;
    delete json;
    
    return 0;
}

6️⃣ 데코레이터 패턴 (Decorator Pattern)

// 기본 컴포넌트 인터페이스
class Weapon {
public:
    virtual ~Weapon() {}
    virtual string getDescription() const = 0;
    virtual int getDamage() const = 0;
};

// 기본 무기
class BasicSword : public Weapon {
public:
    string getDescription() const override {
        return "기본 검";
    }
    
    int getDamage() const override {
        return 10;
    }
};

// 데코레이터 기본 클래스
class WeaponDecorator : public Weapon {
protected:
    Weapon* weapon;
    
public:
    WeaponDecorator(Weapon* w) : weapon(w) {}
    virtual ~WeaponDecorator() { delete weapon; }
};

// 구체적인 데코레이터들
class FireEnchantment : public WeaponDecorator {
public:
    FireEnchantment(Weapon* w) : WeaponDecorator(w) {}
    
    string getDescription() const override {
        return weapon->getDescription() + " + 화염 강화 🔥";
    }
    
    int getDamage() const override {
        return weapon->getDamage() + 15;
    }
};

class PoisonEnchantment : public WeaponDecorator {
public:
    PoisonEnchantment(Weapon* w) : WeaponDecorator(w) {}
    
    string getDescription() const override {
        return weapon->getDescription() + " + 독 강화 ☠️";
    }
    
    int getDamage() const override {
        return weapon->getDamage() + 10;
    }
};

class SharpnessEnchantment : public WeaponDecorator {
public:
    SharpnessEnchantment(Weapon* w) : WeaponDecorator(w) {}
    
    string getDescription() const override {
        return weapon->getDescription() + " + 날카로움 강화 ⚔️";
    }
    
    int getDamage() const override {
        return weapon->getDamage() + 8;
    }
};

// 사용 예시
int main() {
    // 기본 검
    Weapon* sword = new BasicSword();
    cout << sword->getDescription() << endl;
    cout << "공격력: " << sword->getDamage() << endl << endl;
    
    // 화염 강화 추가
    Weapon* fireSword = new FireEnchantment(new BasicSword());
    cout << fireSword->getDescription() << endl;
    cout << "공격력: " << fireSword->getDamage() << endl << endl;
    
    // 여러 강화 중첩!
    Weapon* ultimateSword = new SharpnessEnchantment(
        new PoisonEnchantment(
            new FireEnchantment(
                new BasicSword()
            )
        )
    );
    cout << ultimateSword->getDescription() << endl;
    cout << "공격력: " << ultimateSword->getDamage() << endl;
    
    delete sword;
    delete fireSword;
    delete ultimateSword;
    
    return 0;
}

🎯 SOLID 원칙 실전 예제

// ❌ 나쁜 예: 여러 책임을 가진 클래스
class User {
private:
    string name;
    string email;
    
public:
    void setName(const string& n) { name = n; }
    void setEmail(const string& e) { email = e; }
    
    // 데이터베이스 저장 (책임 1)
    void saveToDatabase() {
        cout << "DB에 저장..." << endl;
    }
    
    // 이메일 전송 (책임 2)
    void sendEmail(const string& message) {
        cout << "이메일 전송..." << endl;
    }
    
    // 로그 기록 (책임 3)
    void log(const string& action) {
        cout << "로그: " << action << endl;
    }
};

// ✅ 좋은 예: 책임을 분리
class User {
private:
    string name;
    string email;
    
public:
    void setName(const string& n) { name = n; }
    void setEmail(const string& e) { email = e; }
    string getName() const { return name; }
    string getEmail() const { return email; }
};

class UserRepository {
public:
    void save(const User& user) {
        cout << "DB에 " << user.getName() << " 저장" << endl;
    }
};

class EmailService {
public:
    void send(const User& user, const string& message) {
        cout << user.getEmail() << "로 이메일 전송" << endl;
    }
};

class Logger {
public:
    void log(const string& action) {
        cout << "로그: " << action << endl;
    }
};

// ✅ OCP를 따르는 설계
class Shape {
public:
    virtual ~Shape() {}
    virtual double calculateArea() const = 0;
};

class Circle : public Shape {
private:
    double radius;
public:
    Circle(double r) : radius(r) {}
    double calculateArea() const override {
        return 3.14159 * radius * radius;
    }
};

class Rectangle : public Shape {
private:
    double width, height;
public:
    Rectangle(double w, double h) : width(w), height(h) {}
    double calculateArea() const override {
        return width * height;
    }
};

// 새로운 도형 추가 시 기존 코드 수정 불필요!
class Triangle : public Shape {
private:
    double base, height;
public:
    Triangle(double b, double h) : base(b), height(h) {}
    double calculateArea() const override {
        return 0.5 * base * height;
    }
};

class AreaCalculator {
public:
    double calculateTotalArea(const vector<Shape*>& shapes) {
        double total = 0;
        for (const Shape* shape : shapes) {
            total += shape->calculateArea();
        }
        return total;
    }
};

// ❌ 나쁜 예: 구체 클래스에 의존
class MySQLDatabase {
public:
    void connect() { cout << "MySQL 연결" << endl; }
    void query(const string& sql) { cout << "쿼리 실행: " << sql << endl; }
};

class UserService {
private:
    MySQLDatabase db;  // 구체 클래스에 직접 의존!
public:
    void getUser(int id) {
        db.connect();
        db.query("SELECT * FROM users WHERE id = " + to_string(id));
    }
};

// ✅ 좋은 예: 추상화에 의존
class IDatabase {
public:
    virtual ~IDatabase() {}
    virtual void connect() = 0;
    virtual void query(const string& sql) = 0;
};

class MySQLDatabase : public IDatabase {
public:
    void connect() override { cout << "MySQL 연결" << endl; }
    void query(const string& sql) override { 
        cout << "MySQL 쿼리: " << sql << endl; 
    }
};

class PostgreSQLDatabase : public IDatabase {
public:
    void connect() override { cout << "PostgreSQL 연결" << endl; }
    void query(const string& sql) override { 
        cout << "PostgreSQL 쿼리: " << sql << endl; 
    }
};

class UserService {
private:
    IDatabase* db;  // 추상화에 의존!
public:
    UserService(IDatabase* database) : db(database) {}
    
    void getUser(int id) {
        db->connect();
        db->query("SELECT * FROM users WHERE id = " + to_string(id));
    }
};

// 사용 예시
int main() {
    // 데이터베이스를 쉽게 교체 가능!
    IDatabase* mysql = new MySQLDatabase();
    UserService service1(mysql);
    service1.getUser(1);
    
    IDatabase* postgres = new PostgreSQLDatabase();
    UserService service2(postgres);
    service2.getUser(2);
    
    delete mysql;
    delete postgres;
    return 0;
}

// ========== 컴포넌트 시스템 ==========
class Component {
public:
    virtual ~Component() {}
    virtual void update(float deltaTime) = 0;
    virtual string getType() const = 0;
};

class TransformComponent : public Component {
private:
    float x, y;
    float rotation;
    
public:
    TransformComponent(float px = 0, float py = 0) 
        : x(px), y(py), rotation(0) {}
    
    void update(float deltaTime) override {
        // 위치 업데이트 로직
    }
    
    string getType() const override { return "Transform"; }
    
    void setPosition(float px, float py) { x = px; y = py; }
    void move(float dx, float dy) { x += dx; y += dy; }
    float getX() const { return x; }
    float getY() const { return y; }
};

class RenderComponent : public Component {
private:
    string spriteName;
    
public:
    RenderComponent(const string& sprite) : spriteName(sprite) {}
    
    void update(float deltaTime) override {
        // 렌더링 로직
        cout << "렌더링: " << spriteName << endl;
    }
    
    string getType() const override { return "Render"; }
};

class PhysicsComponent : public Component {
private:
    float velocityX, velocityY;
    float mass;
    
public:
    PhysicsComponent(float m = 1.0f) 
        : velocityX(0), velocityY(0), mass(m) {}
    
    void update(float deltaTime) override {
        // 물리 시뮬레이션
    }
    
    string getType() const override { return "Physics"; }
    
    void applyForce(float fx, float fy) {
        velocityX += fx / mass;
        velocityY += fy / mass;
    }
};

// ========== 게임 오브젝트 ==========
class GameObject {
private:
    string name;
    vector<Component*> components;
    bool active;
    
public:
    GameObject(const string& n) : name(n), active(true) {}
    
    ~GameObject() {
        for (Component* comp : components) {
            delete comp;
        }
    }
    
    void addComponent(Component* component) {
        components.push_back(component);
    }
    
    template<typename T>
    T* getComponent() {
        for (Component* comp : components) {
            T* result = dynamic_cast<T*>(comp);
            if (result != nullptr) {
                return result;
            }
        }
        return nullptr;
    }
    
    void update(float deltaTime) {
        if (!active) return;
        
        for (Component* comp : components) {
            comp->update(deltaTime);
        }
    }
    
    void setActive(bool isActive) { active = isActive; }
    bool isActive() const { return active; }
    string getName() const { return name; }
};

// ========== 씬 관리 ==========
class Scene {
private:
    string name;
    vector<GameObject*> gameObjects;
    
public:
    Scene(const string& n) : name(n) {}
    
    ~Scene() {
        for (GameObject* obj : gameObjects) {
            delete obj;
        }
    }
    
    void addGameObject(GameObject* obj) {
        gameObjects.push_back(obj);
    }
    
    void update(float deltaTime) {
        for (GameObject* obj : gameObjects) {
            if (obj->isActive()) {
                obj->update(deltaTime);
            }
        }
    }
    
    GameObject* findGameObject(const string& name) {
        for (GameObject* obj : gameObjects) {
            if (obj->getName() == name) {
                return obj;
            }
        }
        return nullptr;
    }
    
    string getName() const { return name; }
};

// ========== 게임 엔진 (싱글톤) ==========
class GameEngine {
private:
    static GameEngine* instance;
    Scene* currentScene;
    bool running;
    
    GameEngine() : currentScene(nullptr), running(false) {}
    
public:
    static GameEngine* getInstance() {
        if (instance == nullptr) {
            instance = new GameEngine();
        }
        return instance;
    }
    
    void loadScene(Scene* scene) {
        if (currentScene != nullptr) {
            delete currentScene;
        }
        currentScene = scene;
        cout << "씬 로드: " << scene->getName() << " 🎬" << endl;
    }
    
    void start() {
        running = true;
        cout << "게임 시작! 🎮" << endl;
    }
    
    void update(float deltaTime) {
        if (running && currentScene != nullptr) {
            currentScene->update(deltaTime);
        }
    }
    
    void stop() {
        running = false;
        cout << "게임 종료! 👋" << endl;
    }
    
    Scene* getCurrentScene() { return currentScene; }
};

GameEngine* GameEngine::instance = nullptr;

// ========== 사용 예시 ==========
int main() {
    GameEngine* engine = GameEngine::getInstance();
    
    // 씬 생성
    Scene* mainScene = new Scene("메인 게임");
    
    // 플레이어 오브젝트 생성
    GameObject* player = new GameObject("플레이어");
    player->addComponent(new TransformComponent(100, 100));
    player->addComponent(new RenderComponent("player_sprite.png"));
    player->addComponent(new PhysicsComponent(1.5f));
    mainScene->addGameObject(player);
    
    // 적 오브젝트 생성
    GameObject* enemy = new GameObject("적");
    enemy->addComponent(new TransformComponent(300, 200));
    enemy->addComponent(new RenderComponent("enemy_sprite.png"));
    enemy->addComponent(new PhysicsComponent(1.0f));
    mainScene->addGameObject(enemy);
    
    // 배경 오브젝트
    GameObject* background = new GameObject("배경");
    background->addComponent(new TransformComponent(0, 0));
    background->addComponent(new RenderComponent("background.png"));
    mainScene->addGameObject(background);
    
    // 게임 실행
    engine->loadScene(mainScene);
    engine->start();
    
    // 게임 루프 시뮬레이션
    cout << "\n=== 게임 루프 시작 ===" << endl;
    for (int i = 0; i < 3; i++) {
        cout << "\n--- 프레임 " << i + 1 << " ---" << endl;
        engine->update(0.016f);  // 약 60 FPS
        
        // 플레이어 이동
        TransformComponent* playerTransform = 
            player->getComponent<TransformComponent>();
        if (playerTransform) {
            playerTransform->move(10, 0);
            cout << "플레이어 위치: (" 
                 << playerTransform->getX() << ", " 
                 << playerTransform->getY() << ")" << endl;
        }
    }
    
    engine->stop();
    
    return 0;
}

1️⃣ 가상함수 성능 고려사항

// 성능이 정말 중요한 경우
class FastObject {
public:
    // final을 붙이면 컴파일러가 최적화 가능!
    virtual void criticalFunction() final {
        // 성능 중요한 코드
    }
};

// 또는 템플릿으로 컴파일 타임 다형성 활용
template<typename T>
class OptimizedContainer {
public:
    void process(T& item) {
        item.doSomething();  // 가상함수 호출 없음!
    }
};

2️⃣ 스마트 포인터 활용하기

#include <memory>

class ModernGameObject {
private:
    vector<unique_ptr<Component>> components;  // 자동 메모리 관리!
    
public:
    void addComponent(unique_ptr<Component> comp) {
        components.push_back(move(comp));
    }
    
    // 소멸자에서 delete 할 필요 없음!
    ~ModernGameObject() = default;
};

// 사용 예시
int main() {
    auto obj = make_unique<ModernGameObject>();
    obj->addComponent(make_unique<TransformComponent>(0, 0));
    obj->addComponent(make_unique<RenderComponent>("sprite.png"));
    
    // obj가 스코프를 벗어나면 자동으로 메모리 해제!
    return 0;
}

3️⃣ 인터페이스 설계 원칙

// 좋은 예: 각 인터페이스가 명확한 역할
class IMovable {
public:
    virtual void move(float dx, float dy) = 0;
    virtual ~IMovable() {}
};

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

class ICollidable {
public:
    virtual bool checkCollision(const ICollidable& other) = 0;
    virtual ~ICollidable() {}
};

// 나쁜 예: 너무 많은 책임
class IGameObject {
public:
    virtual void move(float dx, float dy) = 0;
    virtual void render() = 0;
    virtual bool checkCollision(const IGameObject& other) = 0;
    virtual void playSound() = 0;
    virtual void updateAI() = 0;
    virtual void saveToFile() = 0;
    // ... 너무 많아!
};

4️⃣ 예외 안전성 보장

class SafeComponent : public Component {
public:
    void update(float deltaTime) override {
        try {
            // 위험할 수 있는 작업
            performUpdate(deltaTime);
        } catch (const exception& e) {
            // 예외 처리
            cerr << "컴포넌트 업데이트 실패: " << e.what() << endl;
            // 복구 로직
        }
    }
    
private:
    void performUpdate(float deltaTime) {
        // 실제 업데이트 로직
    }
};

5️⃣ 문서화와 주석

/**
 * @brief 게임 오브젝트의 기본 컴포넌트 인터페이스
 * 
 * 모든 컴포넌트는 이 인터페이스를 구현해야 합니다.
 * 각 프레임마다 update() 메서드가 호출됩니다.
 */
class Component {
public:
    virtual ~Component() {}
    
    /**
     * @brief 컴포넌트 업데이트
     * @param deltaTime 이전 프레임으로부터 경과한 시간 (초 단위)
     * 
     * 이 메서드는 매 프레임마다 호출되므로 성능에 주의해야 합니다.
     */
    virtual void update(float deltaTime) = 0;
    
    /**
     * @brief 컴포넌트 타입 반환
     * @return 컴포넌트의 타입 문자열
     */
    virtual string getType() const = 0;
};

📚 단계별 학습 로드맵

💻 추천 학습 자료

❌ 실수 1: 가상 소멸자 빼먹기

// 문제 코드
class Base {
public:
    ~Base() { cout << "Base 소멸" << endl; }  // virtual 없음!
};

class Derived : public Base {
private:
    int* data;
public:
    Derived() { data = new int[1000]; }
    ~Derived() { 
        delete[] data;  // 이게 호출 안 됨!
        cout << "Derived 소멸" << endl; 
    }
};

Base* ptr = new Derived();
delete ptr;  // 메모리 누수 발생! 💥

// 해결책
class Base {
public:
    virtual ~Base() { cout << "Base 소멸" << endl; }  // virtual 추가!
};

❌ 실수 2: 슬라이싱 문제

// 문제 코드
class Animal {
public:
    virtual void speak() { cout << "동물 소리" << endl; }
};

class Dog : public Animal {
public:
    void speak() override { cout << "멍멍!" << endl; }
};

void makeSound(Animal animal) {  // 값으로 전달! 위험!
    animal.speak();
}

Dog dog;
makeSound(dog);  // "동물 소리" 출력 (슬라이싱 발생!)

// 해결책: 포인터나 참조 사용
void makeSound(Animal& animal) {  // 참조로 전달!
    animal.speak();
}

makeSound(dog);  // "멍멍!" 출력 ✅

❌ 실수 3: 순수 가상함수 미구현

// 문제 코드
class Shape {
public:
    virtual double getArea() const = 0;
    virtual void draw() const = 0;
};

class Circle : public Shape {
public:
    double getArea() const override { return 3.14 * r * r; }
    // draw()를 구현 안 함!
};

Circle c;  // 컴파일 에러! 추상클래스는 인스턴스화 불가

// 해결책: 모든 순수 가상함수 구현
class Circle : public Shape {
public:
    double getArea() const override { return 3.14 * r * r; }
    void draw() const override { cout << "원 그리기" << endl; }  // 구현!
};

❌ 실수 4: 다중 상속 다이아몬드 문제

// 문제 코드
class A {
public:
    int value;
};

class B : public A { };
class C : public A { };
class D : public B, public C { };  // 다이아몬드 상속!

D d;
d.value = 10;  // 컴파일 에러! value가 모호함

// 해결책 1: 가상 상속
class B : virtual public A { };
class C : virtual public A { };
class D : public B, public C { };  // 이제 OK!

// 해결책 2: 인터페이스 사용 (더 권장)
class IB {
public:
    virtual void funcB() = 0;
};

class IC {
public:
    virtual void funcC() = 0;
};

class D : public IB, public IC {
    // 각각 구현
};

❌ 실수 5: override 키워드 안 쓰기

// 문제 코드
class Base {
public:
    virtual void func(int x) { }
};

class Derived : public Base {
public:
    void func(double x) { }  // 오버라이드가 아니라 오버로드!
};

Base* ptr = new Derived();
ptr->func(10);  // Base::func 호출됨! 😱

// 해결책: override 키워드 사용
class Derived : public Base {
public:
    void func(double x) override { }  // 컴파일 에러 발생! 👍
    // 올바른 시그니처로 수정
    void func(int x) override { }  // 이제 OK!
};