// ❌ 나쁜 예: 여러 책임을 가진 클래스
class UserManager {
public:
    void createUser(const std::string& name);
    void deleteUser(int userId);
    void sendEmail(int userId, const std::string& message);  // 이메일 발송은 다른 책임!
    void generateReport(int userId);  // 리포트 생성도 다른 책임!
    void validateUserData(const UserData& data);  // 검증도 별도 책임!
};

// ✅ 좋은 예: 책임을 분리
class UserRepository {
public:
    void createUser(const std::string& name);
    void deleteUser(int userId);
    User getUser(int userId);
};

class EmailService {
public:
    void sendEmail(int userId, const std::string& message);
};

class ReportGenerator {
public:
    Report generateUserReport(int userId);
};

class UserValidator {
public:
    bool validate(const UserData& data);
};

// ❌ 나쁜 예: 새로운 도형 추가 시 기존 코드 수정 필요
class Shape {
public:
    enum Type { CIRCLE, RECTANGLE, TRIANGLE };
    Type type;
};

double calculateArea(const Shape& shape) {
    if (shape.type == Shape::CIRCLE) {
        // 원 면적 계산
    } else if (shape.type == Shape::RECTANGLE) {
        // 사각형 면적 계산
    }
    // 새로운 도형 추가 시 여기를 수정해야 함!
}

// ✅ 좋은 예: 다형성을 활용한 확장
class Shape {
public:
    virtual ~Shape() = default;
    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;
    }
};

// ❌ 나쁜 예: LSP 위반
class Bird {
public:
    virtual void fly() { /* 날기 */ }
};

class Penguin : public Bird {
public:
    void fly() override {
        throw std::logic_error("펭귄은 날 수 없어요!");  // 부모의 계약 위반!
    }
};

// ✅ 좋은 예: 올바른 추상화
class Bird {
public:
    virtual ~Bird() = default;
    virtual void move() = 0;
};

class FlyingBird : public Bird {
public:
    void move() override { fly(); }
    virtual void fly() = 0;
};

class FlightlessBird : public Bird {
public:
    void move() override { walk(); }
    virtual void walk() = 0;
};

class Sparrow : public FlyingBird {
public:
    void fly() override { /* 참새가 나는 구현 */ }
};

class Penguin : public FlightlessBird {
public:
    void walk() override { /* 펭귄이 걷는 구현 */ }
};

// ❌ 나쁜 예: 비대한 인터페이스
class IWorker {
public:
    virtual void work() = 0;
    virtual void eat() = 0;
    virtual void sleep() = 0;
};

class Robot : public IWorker {
public:
    void work() override { /* 작업 */ }
    void eat() override { /* 로봇은 먹지 않는데... */ }
    void sleep() override { /* 로봇은 자지 않는데... */ }
};

// ✅ 좋은 예: 인터페이스 분리
class IWorkable {
public:
    virtual void work() = 0;
};

class IEatable {
public:
    virtual void eat() = 0;
};

class ISleepable {
public:
    virtual void sleep() = 0;
};

class Human : public IWorkable, public IEatable, public ISleepable {
public:
    void work() override { /* 작업 */ }
    void eat() override { /* 식사 */ }
    void sleep() override { /* 수면 */ }
};

class Robot : public IWorkable {
public:
    void work() override { /* 작업 */ }
    // 필요한 인터페이스만 구현!
};

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

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

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

class MySQLDatabase : public IDatabase {
public:
    void connect() override { /* MySQL 연결 */ }
    void query(const std::string& sql) override { /* 쿼리 실행 */ }
};

class PostgreSQLDatabase : public IDatabase {
public:
    void connect() override { /* PostgreSQL 연결 */ }
    void query(const std::string& sql) override { /* 쿼리 실행 */ }
};

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

// 계층화 아키텍처 예시

// Infrastructure Layer - 데이터 접근
class IUserRepository {
public:
    virtual ~IUserRepository() = default;
    virtual User findById(int id) = 0;
    virtual void save(const User& user) = 0;
};

class MySQLUserRepository : public IUserRepository {
public:
    User findById(int id) override {
        // MySQL에서 사용자 조회
    }
    void save(const User& user) override {
        // MySQL에 사용자 저장
    }
};

// Domain Layer - 비즈니스 로직
class User {
private:
    int id;
    std::string name;
    std::string email;
    
public:
    User(int id, const std::string& name, const std::string& email)
        : id(id), name(name), email(email) {}
    
    bool isValidEmail() const {
        // 이메일 유효성 검증 로직
        return email.find('@') != std::string::npos;
    }
    
    void updateEmail(const std::string& newEmail) {
        if (!isValidEmail()) {
            throw std::invalid_argument("Invalid email format");
        }
        email = newEmail;
    }
};

// Application Layer - 유스케이스 조율
class UserService {
private:
    std::shared_ptr<IUserRepository> userRepository;
    
public:
    UserService(std::shared_ptr<IUserRepository> repo) 
        : userRepository(repo) {}
    
    void updateUserEmail(int userId, const std::string& newEmail) {
        User user = userRepository->findById(userId);
        user.updateEmail(newEmail);  // 도메인 로직 활용
        userRepository->save(user);
    }
};

// Presentation Layer - 사용자 인터페이스
class UserController {
private:
    std::shared_ptr<UserService> userService;
    
public:
    UserController(std::shared_ptr<UserService> service)
        : userService(service) {}
    
    void handleUpdateEmailRequest(int userId, const std::string& newEmail) {
        try {
            userService->updateUserEmail(userId, newEmail);
            std::cout << "Email updated successfully!" << std::endl;
        } catch (const std::exception& e) {
            std::cerr << "Error: " << e.what() << std::endl;
        }
    }
};

// UserManager.h - 인터페이스 정의
#ifndef USER_MANAGER_H
#define USER_MANAGER_H

#include <string>
#include <memory>

// 전방 선언으로 의존성 최소화
class User;
class IUserRepository;

class UserManager {
private:
    std::unique_ptr<IUserRepository> repository;
    
public:
    explicit UserManager(std::unique_ptr<IUserRepository> repo);
    ~UserManager();
    
    // 복사/이동 생성자 삭제 (싱글톤 패턴 등에 활용)
    UserManager(const UserManager&) = delete;
    UserManager& operator=(const UserManager&) = delete;
    
    void createUser(const std::string& name, const std::string& email);
    User getUser(int userId);
    void deleteUser(int userId);
};

#endif // USER_MANAGER_H

// UserManager.cpp - 구현
#include "UserManager.h"
#include "User.h"
#include "IUserRepository.h"

UserManager::UserManager(std::unique_ptr<IUserRepository> repo)
    : repository(std::move(repo)) {
}

UserManager::~UserManager() = default;

void UserManager::createUser(const std::string& name, const std::string& email) {
    User newUser(0, name, email);
    repository->save(newUser);
}

User UserManager::getUser(int userId) {
    return repository->findById(userId);
}

void UserManager::deleteUser(int userId) {
    repository->remove(userId);
}

// Widget.h - Pimpl 패턴 적용
#ifndef WIDGET_H
#define WIDGET_H

#include <memory>

class Widget {
private:
    class Impl;  // 전방 선언
    std::unique_ptr<Impl> pImpl;  // 구현 포인터
    
public:
    Widget();
    ~Widget();
    
    // 복사/이동 생성자는 명시적으로 선언
    Widget(const Widget& other);
    Widget& operator=(const Widget& other);
    Widget(Widget&& other) noexcept;
    Widget& operator=(Widget&& other) noexcept;
    
    void doSomething();
    int getValue() const;
};

#endif // WIDGET_H

// Widget.cpp
#include "Widget.h"
#include <iostream>
#include <vector>
#include "SomeHeavyDependency.h"  // 헤더에서는 보이지 않음!

// 실제 구현 클래스
class Widget::Impl {
public:
    std::vector<int> data;
    SomeHeavyDependency dependency;
    
    void doSomething() {
        std::cout << "Doing something..." << std::endl;
        dependency.process(data);
    }
    
    int getValue() const {
        return data.empty() ? 0 : data[0];
    }
};

// Widget 생성자/소멸자 구현
Widget::Widget() : pImpl(std::make_unique<Impl>()) {}
Widget::~Widget() = default;

Widget::Widget(const Widget& other) 
    : pImpl(std::make_unique<Impl>(*other.pImpl)) {}

Widget& Widget::operator=(const Widget& other) {
    *pImpl = *other.pImpl;
    return *this;
}

Widget::Widget(Widget&& other) noexcept = default;
Widget& Widget::operator=(Widget&& other) noexcept = default;

void Widget::doSomething() {
    pImpl->doSomething();
}

int Widget::getValue() const {
    return pImpl->getValue();
}

// 계층적 네임스페이스 구조
namespace MyCompany {
    namespace Graphics {
        namespace Rendering {
            class Renderer {
            public:
                void render();
            };
            
            class Shader {
            public:
                void compile();
            };
        }
        
        namespace UI {
            class Button {
            public:
                void draw();
            };
            
            class Window {
            public:
                void show();
            };
        }
    }
    
    namespace Audio {
        class AudioEngine {
        public:
            void playSound();
        };
        
        class Mixer {
        public:
            void mix();
        };
    }
}

// C++17 이후 중첩 네임스페이스 간편 표기
namespace MyCompany::Graphics::Rendering {
    void Renderer::render() {
        // 렌더링 구현
    }
}

// 사용 예시
int main() {
    MyCompany::Graphics::Rendering::Renderer renderer;
    renderer.render();
    
    // using 선언으로 간편하게
    using namespace MyCompany::Graphics::UI;
    Button button;
    button.draw();
    
    return 0;
}

// math_module.cppm - 모듈 인터페이스 파일
export module math_utils;

import <cmath>;
import <numbers>;

// 외부로 공개할 함수들
export namespace MathUtils {
    double calculateCircleArea(double radius) {
        return std::numbers::pi * radius * radius;
    }
    
    double calculateSquareRoot(double value) {
        return std::sqrt(value);
    }
    
    // 내부 구현 (export 없음 - 외부에서 접근 불가)
    namespace Internal {
        double helperFunction(double x) {
            return x * 2.0;
        }
    }
}

// 클래스도 export 가능
export class Calculator {
private:
    double result = 0.0;
    
public:
    void add(double value) {
        result += value;
    }
    
    void multiply(double value) {
        result *= value;
    }
    
    double getResult() const {
        return result;
    }
};

// main.cpp - 모듈 사용
import math_utils;
import <iostream>;

int main() {
    // 모듈에서 export한 함수 사용
    double area = MathUtils::calculateCircleArea(5.0);
    std::cout << "Circle area: " << area << std::endl;
    
    // export한 클래스 사용
    Calculator calc;
    calc.add(10);
    calc.multiply(2);
    std::cout << "Result: " << calc.getResult() << std::endl;
    
    // MathUtils::Internal::helperFunction은 접근 불가!
    // (export되지 않았기 때문)
    
    return 0;
}

// MathLibrary.h
#ifndef MATH_LIBRARY_H
#define MATH_LIBRARY_H

namespace MathLib {
    double add(double a, double b);
    double multiply(double a, double b);
    double power(double base, int exponent);
}

#endif

// MathLibrary.cpp
#include "MathLibrary.h"
#include <cmath>

namespace MathLib {
    double add(double a, double b) {
        return a + b;
    }
    
    double multiply(double a, double b) {
        return a * b;
    }
    
    double power(double base, int exponent) {
        return std::pow(base, exponent);
    }
}

# CMakeLists.txt - 정적 라이브러리 빌드
cmake_minimum_required(VERSION 3.15)
project(MathLibrary)

# 정적 라이브러리 생성
add_library(MathLib STATIC
    MathLibrary.cpp
)

target_include_directories(MathLib PUBLIC
    ${CMAKE_CURRENT_SOURCE_DIR}
)

# 사용하는 프로젝트
add_executable(MyApp main.cpp)
target_link_libraries(MyApp PRIVATE MathLib)

// PluginInterface.h
#ifndef PLUGIN_INTERFACE_H
#define PLUGIN_INTERFACE_H

#ifdef _WIN32
    #ifdef BUILDING_DLL
        #define DLL_EXPORT __declspec(dllexport)
    #else
        #define DLL_EXPORT __declspec(dllimport)
    #endif
#else
    #define DLL_EXPORT __attribute__((visibility("default")))
#endif

class DLL_EXPORT IPlugin {
public:
    virtual ~IPlugin() = default;
    virtual void initialize() = 0;
    virtual void execute() = 0;
    virtual void shutdown() = 0;
};

// 플러그인 생성 함수
extern "C" DLL_EXPORT IPlugin* createPlugin();
extern "C" DLL_EXPORT void destroyPlugin(IPlugin* plugin);

#endif

// AudioPlugin.cpp - 동적 라이브러리 구현
#include "PluginInterface.h"
#include <iostream>

class AudioPlugin : public IPlugin {
public:
    void initialize() override {
        std::cout << "Audio plugin initialized" << std::endl;
    }
    
    void execute() override {
        std::cout << "Playing audio..." << std::endl;
    }
    
    void shutdown() override {
        std::cout << "Audio plugin shutdown" << std::endl;
    }
};

// 외부에서 호출할 팩토리 함수
extern "C" DLL_EXPORT IPlugin* createPlugin() {
    return new AudioPlugin();
}

extern "C" DLL_EXPORT void destroyPlugin(IPlugin* plugin) {
    delete plugin;
}

// PluginLoader.cpp - 동적 라이브러리 로딩
#include <iostream>
#include <memory>

#ifdef _WIN32
    #include <windows.h>
    typedef HMODULE LibHandle;
#else
    #include <dlfcn.h>
    typedef void* LibHandle;
#endif

#include "PluginInterface.h"

class PluginLoader {
private:
    LibHandle handle = nullptr;
    IPlugin* plugin = nullptr;
    
public:
    bool loadPlugin(const std::string& path) {
#ifdef _WIN32
        handle = LoadLibraryA(path.c_str());
#else
        handle = dlopen(path.c_str(), RTLD_LAZY);
#endif
        
        if (!handle) {
            std::cerr << "Failed to load plugin" << std::endl;
            return false;
        }
        
        // 함수 포인터 가져오기
        typedef IPlugin* (*CreateFunc)();
#ifdef _WIN32
        CreateFunc createFunc = (CreateFunc)GetProcAddress(handle, "createPlugin");
#else
        CreateFunc createFunc = (CreateFunc)dlsym(handle, "createPlugin");
#endif
        
        if (!createFunc) {
            std::cerr << "Failed to find createPlugin function" << std::endl;
            return false;
        }
        
        plugin = createFunc();
        return plugin != nullptr;
    }
    
    IPlugin* getPlugin() {
        return plugin;
    }
    
    ~PluginLoader() {
        if (plugin) {
            typedef void (*DestroyFunc)(IPlugin*);
#ifdef _WIN32
            DestroyFunc destroyFunc = (DestroyFunc)GetProcAddress(handle, "destroyPlugin");
#else
            DestroyFunc destroyFunc = (DestroyFunc)dlsym(handle, "destroyPlugin");
#endif
            if (destroyFunc) {
                destroyFunc(plugin);
            }
        }
        
        if (handle) {
#ifdef _WIN32
            FreeLibrary(handle);
#else
            dlclose(handle);
#endif
        }
    }
};

int main() {
    PluginLoader loader;
    
    if (loader.loadPlugin("./libAudioPlugin.so")) {
        IPlugin* plugin = loader.getPlugin();
        plugin->initialize();
        plugin->execute();
        plugin->shutdown();
    }
    
    return 0;
}

// 문제 상황: 고수준 모듈이 저수준 모듈에 직접 의존
// HighLevelModule.h
#include "LowLevelModule.h"  // 직접 의존!

class HighLevelModule {
private:
    LowLevelModule lowLevel;  // 구체 클래스에 의존
public:
    void doSomething() {
        lowLevel.operation();
    }
};

// 이 구조의 문제점:
// 1. LowLevelModule 변경 시 HighLevelModule도 재컴파일
// 2. LowLevelModule을 다른 구현으로 교체하기 어려움
// 3. 테스트 시 Mock 객체 사용 불가

// 해결책: 추상화를 통한 의존성 역전
// IService.h - 추상 인터페이스
#ifndef ISERVICE_H
#define ISERVICE_H

class IService {
public:
    virtual ~IService() = default;
    virtual void operation() = 0;
};

#endif

// HighLevelModule.h - 추상화에 의존
#ifndef HIGH_LEVEL_MODULE_H
#define HIGH_LEVEL_MODULE_H

#include "IService.h"
#include <memory>

class HighLevelModule {
private:
    std::unique_ptr<IService> service;  // 인터페이스에 의존
    
public:
    explicit HighLevelModule(std::unique_ptr<IService> svc)
        : service(std::move(svc)) {}
    
    void doSomething() {
        service->operation();
    }
};

#endif

// LowLevelModule.h - 인터페이스 구현
#ifndef LOW_LEVEL_MODULE_H
#define LOW_LEVEL_MODULE_H

#include "IService.h"

class LowLevelModule : public IService {
public:
    void operation() override;
};

#endif

// main.cpp - 의존성 주입
#include "HighLevelModule.h"
#include "LowLevelModule.h"
#include <memory>

int main() {
    // 런타임에 구체적인 구현 주입
    auto service = std::make_unique<LowLevelModule>();
    HighLevelModule module(std::move(service));
    
    module.doSomething();
    
    return 0;
}

// ❌ 순환 의존성 문제
// ClassA.h
#ifndef CLASS_A_H
#define CLASS_A_H

#include "ClassB.h"  // B를 include

class ClassA {
private:
    ClassB b;  // B 객체 멤버
public:
    void useB();
};

#endif

// ClassB.h
#ifndef CLASS_B_H
#define CLASS_B_H

#include "ClassA.h"  // A를 include (순환!)

class ClassB {
private:
    ClassA a;  // A 객체 멤버
public:
    void useA();
};

#endif

// 컴파일 에러 발생!

// ClassA.h
#ifndef CLASS_A_H
#define CLASS_A_H

class ClassB;  // 전방 선언 (include 대신)

class ClassA {
private:
    ClassB* b;  // 포인터나 참조만 가능
public:
    ClassA();
    ~ClassA();
    void useB();
};

#endif

// ClassA.cpp
#include "ClassA.h"
#include "ClassB.h"  // 구현 파일에서 include

ClassA::ClassA() : b(new ClassB()) {}
ClassA::~ClassA() { delete b; }

void ClassA::useB() {
    b->someMethod();  // 이제 사용 가능
}

// IObserver.h - 인터페이스 정의
#ifndef IOBSERVER_H
#define IOBSERVER_H

class IObserver {
public:
    virtual ~IObserver() = default;
    virtual void update() = 0;
};

#endif

// Subject.h
#ifndef SUBJECT_H
#define SUBJECT_H

#include "IObserver.h"
#include <vector>
#include <memory>

class Subject {
private:
    std::vector<IObserver*> observers;
    
public:
    void attach(IObserver* observer) {
        observers.push_back(observer);
    }
    
    void notify() {
        for (auto* obs : observers) {
            obs->update();
        }
    }
};

#endif

// ConcreteObserver.h
#ifndef CONCRETE_OBSERVER_H
#define CONCRETE_OBSERVER_H

#include "IObserver.h"
#include "Subject.h"

class ConcreteObserver : public IObserver {
private:
    Subject* subject;
    
public:
    ConcreteObserver(Subject* subj) : subject(subj) {
        subject->attach(this);
    }
    
    void update() override {
        // 업데이트 처리
    }
};

#endif

# conanfile.txt
[requires]
boost/1.80.0
fmt/9.1.0
spdlog/1.11.0

[generators]
cmake

[options]
boost:shared=False

# CMakeLists.txt
cmake_minimum_required(VERSION 3.15)
project(MyProject)

# Conan 설정
include(${CMAKE_BINARY_DIR}/conanbuildinfo.cmake)
conan_basic_setup()

add_executable(myapp main.cpp)

# Conan이 관리하는 라이브러리 링크
target_link_libraries(myapp ${CONAN_LIBS})

# 빌드 명령
mkdir build && cd build
conan install .. --build=missing
cmake ..
cmake --build .

# vcpkg로 라이브러리 설치
vcpkg install boost:x64-windows
vcpkg install fmt:x64-windows
vcpkg install spdlog:x64-windows

# CMakeLists.txt
cmake_minimum_required(VERSION 3.15)
project(MyProject)

# vcpkg 툴체인 파일 사용
# cmake -DCMAKE_TOOLCHAIN_FILE=[vcpkg root]/scripts/buildsystems/vcpkg.cmake

find_package(Boost REQUIRED)
find_package(fmt CONFIG REQUIRED)
find_package(spdlog CONFIG REQUIRED)

add_executable(myapp main.cpp)

target_link_libraries(myapp
    PRIVATE
    Boost::boost
    fmt::fmt
    spdlog::spdlog
)

// 실전 예제: 게임 엔진 아키텍처

// ============ Layer 1: Platform (최하위) ============
// Platform/Window.h
namespace Platform {
    class IWindow {
    public:
        virtual ~IWindow() = default;
        virtual void create(int width, int height) = 0;
        virtual void update() = 0;
        virtual bool shouldClose() = 0;
    };
    
    class WindowsWindow : public IWindow {
        // Windows 구현
    };
    
    class LinuxWindow : public IWindow {
        // Linux 구현
    };
}

// ============ Layer 2: Core (핵심 시스템) ============
// Core/Engine.h
namespace Core {
    class Engine {
    private:
        std::unique_ptr<Platform::IWindow> window;
        bool isRunning = false;
        
    public:
        void initialize() {
#ifdef _WIN32
            window = std::make_unique<Platform::WindowsWindow>();
#else
            window = std::make_unique<Platform::LinuxWindow>();
#endif
            window->create(1920, 1080);
            isRunning = true;
        }
        
        void run() {
            while (isRunning && !window->shouldClose()) {
                update();
                render();
            }
        }
        
        void update() {
            // 게임 로직 업데이트
        }
        
        void render() {
            // 렌더링
        }
    };
}

// ============ Layer 3: Game (게임 로직) ============
// Game/Player.h
namespace Game {
    class Player {
    private:
        float x, y;
        float health;
        
    public:
        Player(float startX, float startY) 
            : x(startX), y(startY), health(100.0f) {}
        
        void move(float dx, float dy) {
            x += dx;
            y += dy;
        }
        
        void takeDamage(float damage) {
            health -= damage;
            if (health < 0) health = 0;
        }
        
        bool isAlive() const {
            return health > 0;
        }
    };
}

// ============ Layer 4: Application (최상위) ============
// main.cpp
int main() {
    Core::Engine engine;
    engine.initialize();
    
    Game::Player player(100, 100);
    
    engine.run();
    
    return 0;
}

// ============ Domain (핵심 비즈니스 로직) ============
// Domain/Order.h
namespace Domain {
    class Order {
    private:
        int id;
        std::string customerId;
        std::vector<std::string> items;
        double totalAmount;
        
    public:
        Order(int id, const std::string& customerId)
            : id(id), customerId(customerId), totalAmount(0.0) {}
        
        void addItem(const std::string& item, double price) {
            items.push_back(item);
            totalAmount += price;
        }
        
        double getTotalAmount() const {
            return totalAmount;
        }
        
        bool isValid() const {
            return !items.empty() && totalAmount > 0;
        }
    };
}

// ============ Ports (인터페이스) ============
// Ports/IOrderRepository.h
namespace Ports {
    class IOrderRepository {
    public:
        virtual ~IOrderRepository() = default;
        virtual void save(const Domain::Order& order) = 0;
        virtual Domain::Order findById(int id) = 0;
    };
    
    class IPaymentGateway {
    public:
        virtual ~IPaymentGateway() = default;
        virtual bool processPayment(double amount) = 0;
    };
    
    class INotificationService {
    public:
        virtual ~INotificationService() = default;
        virtual void sendOrderConfirmation(const std::string& customerId) = 0;
    };
}

// ============ Application (유스케이스) ============
// Application/OrderService.h
namespace Application {
    class OrderService {
    private:
        std::shared_ptr<Ports::IOrderRepository> orderRepo;
        std::shared_ptr<Ports::IPaymentGateway> paymentGateway;
        std::shared_ptr<Ports::INotificationService> notificationService;
        
    public:
        OrderService(
            std::shared_ptr<Ports::IOrderRepository> repo,
            std::shared_ptr<Ports::IPaymentGateway> payment,
            std::shared_ptr<Ports::INotificationService> notification
        ) : orderRepo(repo), 
            paymentGateway(payment), 
            notificationService(notification) {}
        
        bool placeOrder(Domain::Order& order) {
            // 비즈니스 규칙 검증
            if (!order.isValid()) {
                return false;
            }
            
            // 결제 처리
            if (!paymentGateway->processPayment(order.getTotalAmount())) {
                return false;
            }
            
            // 주문 저장
            orderRepo->save(order);
            
            // 알림 발송
            notificationService->sendOrderConfirmation(order.getCustomerId());
            
            return true;
        }
    };
}

// ============ Adapters (구체적인 구현) ============
// Adapters/MySQLOrderRepository.h
namespace Adapters {
    class MySQLOrderRepository : public Ports::IOrderRepository {
    public:
        void save(const Domain::Order& order) override {
            // MySQL에 저장하는 실제 구현
            std::cout << "Saving order to MySQL..." << std::endl;
        }
        
        Domain::Order findById(int id) override {
            // MySQL에서 조회하는 실제 구현
            return Domain::Order(id, "customer123");
        }
    };
    
    class StripePaymentGateway : public Ports::IPaymentGateway {
    public:
        bool processPayment(double amount) override {
            // Stripe API 호출
            std::cout << "Processing payment of $" << amount 
                      << " via Stripe..." << std::endl;
            return true;
        }
    };
    
    class EmailNotificationService : public Ports::INotificationService {
    public:
        void sendOrderConfirmation(const std::string& customerId) override {
            // 이메일 발송
            std::cout << "Sending confirmation email to " 
                      << customerId << std::endl;
        }
    };
}

// ============ Main (의존성 조립) ============
int main() {
    // 어댑터 생성
    auto orderRepo = std::make_shared<Adapters::MySQLOrderRepository>();
    auto paymentGateway = std::make_shared<Adapters::StripePaymentGateway>();
    auto notificationService = std::make_shared<Adapters::EmailNotificationService>();
    
    // 서비스 생성 (의존성 주입)
    Application::OrderService orderService(
        orderRepo, 
        paymentGateway, 
        notificationService
    );
    
    // 주문 생성 및 처리
    Domain::Order order(1, "customer123");
    order.addItem("Laptop", 1200.00);
    order.addItem("Mouse", 25.00);
    
    if (orderService.placeOrder(order)) {
        std::cout << "Order placed successfully!" << std::endl;
    }
    
    return 0;
}

// ============ Event System ============
// Events/Event.h
namespace Events {
    // 기본 이벤트 인터페이스
    class IEvent {
    public:
        virtual ~IEvent() = default;
        virtual std::string getType() const = 0;
    };
    
    // 구체적인 이벤트들
    class PlayerDiedEvent : public IEvent {
    private:
        int playerId;
        std::string cause;
        
    public:
        PlayerDiedEvent(int id, const std::string& cause)
            : playerId(id), cause(cause) {}
        
        std::string getType() const override { return "PlayerDied"; }
        int getPlayerId() const { return playerId; }
        std::string getCause() const { return cause; }
    };
    
    class ScoreChangedEvent : public IEvent {
    private:
        int playerId;
        int newScore;
        
    public:
        ScoreChangedEvent(int id, int score)
            : playerId(id), newScore(score) {}
        
        std::string getType() const override { return "ScoreChanged"; }
        int getPlayerId() const { return playerId; }
        int getNewScore() const { return newScore; }
    };
}

// Events/EventBus.h
namespace Events {
    class IEventListener {
    public:
        virtual ~IEventListener() = default;
        virtual void onEvent(const IEvent& event) = 0;
    };
    
    class EventBus {
    private:
        std::unordered_map<std::string, std::vector<IEventListener*>> listeners;
        std::queue<std::unique_ptr<IEvent>> eventQueue;
        
    public:
        void subscribe(const std::string& eventType, IEventListener* listener) {
            listeners[eventType].push_back(listener);
        }
        
        void unsubscribe(const std::string& eventType, IEventListener* listener) {
            auto& listenerList = listeners[eventType];
            listenerList.erase(
                std::remove(listenerList.begin(), listenerList.end(), listener),
                listenerList.end()
            );
        }
        
        void publish(std::unique_ptr<IEvent> event) {
            eventQueue.push(std::move(event));
        }
        
        void processEvents() {
            while (!eventQueue.empty()) {
                auto& event = eventQueue.front();
                
                auto it = listeners.find(event->getType());
                if (it != listeners.end()) {
                    for (auto* listener : it->second) {
                        listener->onEvent(*event);
                    }
                }
                
                eventQueue.pop();
            }
        }
    };
}

// ============ Game Systems (이벤트 리스너) ============
// Systems/ScoreSystem.h
namespace Systems {
    class ScoreSystem : public Events::IEventListener {
    private:
        std::unordered_map<int, int> playerScores;
        Events::EventBus* eventBus;
        
    public:
        ScoreSystem(Events::EventBus* bus) : eventBus(bus) {
            eventBus->subscribe("PlayerDied", this);
        }
        
        void onEvent(const Events::IEvent& event) override {
            if (event.getType() == "PlayerDied") {
                auto& deathEvent = static_cast<const Events::PlayerDiedEvent&>(event);
                int playerId = deathEvent.getPlayerId();
                
                // 점수 감소
                playerScores[playerId] -= 100;
                
                // 점수 변경 이벤트 발행
                eventBus->publish(
                    std::make_unique<Events::ScoreChangedEvent>(
                        playerId, 
                        playerScores[playerId]
                    )
                );
            }
        }
        
        void addScore(int playerId, int points) {
            playerScores[playerId] += points;
            eventBus->publish(
                std::make_unique<Events::ScoreChangedEvent>(
                    playerId, 
                    playerScores[playerId]
                )
            );
        }
    };
    
    class UISystem : public Events::IEventListener {
    private:
        Events::EventBus* eventBus;
        
    public:
        UISystem(Events::EventBus* bus) : eventBus(bus) {
            eventBus->subscribe("ScoreChanged", this);
            eventBus->subscribe("PlayerDied", this);
        }
        
        void onEvent(const Events::IEvent& event) override {
            if (event.getType() == "ScoreChanged") {
                auto& scoreEvent = static_cast<const Events::ScoreChangedEvent&>(event);
                std::cout << "UI: Player " << scoreEvent.getPlayerId() 
                          << " score updated to " << scoreEvent.getNewScore() 
                          << std::endl;
            }
            else if (event.getType() == "PlayerDied") {
                auto& deathEvent = static_cast<const Events::PlayerDiedEvent&>(event);
                std::cout << "UI: Player " << deathEvent.getPlayerId() 
                          << " died (" << deathEvent.getCause() << ")" 
                          << std::endl;
            }
        }
    };
    
    class AchievementSystem : public Events::IEventListener {
    private:
        Events::EventBus* eventBus;
        
    public:
        AchievementSystem(Events::EventBus* bus) : eventBus(bus) {
            eventBus->subscribe("ScoreChanged", this);
        }
        
        void onEvent(const Events::IEvent& event) override {
            if (event.getType() == "ScoreChanged") {
                auto& scoreEvent = static_cast<const Events::ScoreChangedEvent&>(event);
                
                // 특정 점수 달성 시 업적 해제
                if (scoreEvent.getNewScore() >= 1000) {
                    std::cout << "Achievement Unlocked: Score Master!" 
                              << std::endl;
                }
            }
        }
    };
}

// ============ Main ============
int main() {
    Events::EventBus eventBus;
    
    // 시스템들 생성 (각자 이벤트 구독)
    Systems::ScoreSystem scoreSystem(&eventBus);
    Systems::UISystem uiSystem(&eventBus);
    Systems::AchievementSystem achievementSystem(&eventBus);
    
    // 게임 플레이 시뮬레이션
    std::cout << "=== Game Start ===" << std::endl;
    
    // 점수 획득
    scoreSystem.addScore(1, 500);
    eventBus.processEvents();
    
    std::cout << std::endl;
    
    // 더 많은 점수 획득
    scoreSystem.addScore(1, 600);
    eventBus.processEvents();
    
    std::cout << std::endl;
    
    // 플레이어 사망
    eventBus.publish(
        std::make_unique<Events::PlayerDiedEvent>(1, "fell off cliff")
    );
    eventBus.processEvents();
    
    return 0;
}

// ============ Component (데이터만 담당) ============
namespace ECS {
    // 기본 컴포넌트 인터페이스
    struct IComponent {
        virtual ~IComponent() = default;
    };
    
    // 위치 컴포넌트
    struct TransformComponent : IComponent {
        float x = 0.0f;
        float y = 0.0f;
        float rotation = 0.0f;
    };
    
    // 렌더링 컴포넌트
    struct SpriteComponent : IComponent {
        std::string texturePath;
        int width = 0;
        int height = 0;
    };
    
    // 물리 컴포넌트
    struct PhysicsComponent : IComponent {
        float velocityX = 0.0f;
        float velocityY = 0.0f;
        float mass = 1.0f;
    };
    
    // 체력 컴포넌트
    struct HealthComponent : IComponent {
        float current = 100.0f;
        float maximum = 100.0f;
    };
}

// ============ Entity (컴포넌트 컨테이너) ============
namespace ECS {
    class Entity {
    private:
        int id;
        std::unordered_map<std::type_index, std::unique_ptr<IComponent>> components;
        
    public:
        explicit Entity(int id) : id(id) {}
        
        int getId() const { return id; }
        
        template<typename T>
        T* addComponent() {
            auto component = std::make_unique<T>();
            T* ptr = component.get();
            components[std::type_index(typeid(T))] = std::move(component);
            return ptr;
        }
        
        template<typename T>
        T* getComponent() {
            auto it = components.find(std::type_index(typeid(T)));
            if (it != components.end()) {
                return static_cast<T*>(it->second.get());
            }
            return nullptr;
        }
        
        template<typename T>
        bool hasComponent() const {
            return components.find(std::type_index(typeid(T))) != components.end();
        }
        
        template<typename T>
        void removeComponent() {
            components.erase(std::type_index(typeid(T)));
        }
    };
}

// ============ System (로직 담당) ============
namespace ECS {
    class ISystem {
    public:
        virtual ~ISystem() = default;
        virtual void update(float deltaTime, std::vector<Entity*>& entities) = 0;
    };
    
    // 물리 시스템
    class PhysicsSystem : public ISystem {
    public:
        void update(float deltaTime, std::vector<Entity*>& entities) override {
            for (auto* entity : entities) {
                // Transform과 Physics 컴포넌트가 둘 다 있는 엔티티만 처리
                if (entity->hasComponent<TransformComponent>() &&
                    entity->hasComponent<PhysicsComponent>()) {
                    
                    auto* transform = entity->getComponent<TransformComponent>();
                    auto* physics = entity->getComponent<PhysicsComponent>();
                    
                    // 속도에 따라 위치 업데이트
                    transform->x += physics->velocityX * deltaTime;
                    transform->y += physics->velocityY * deltaTime;
                    
                    // 중력 적용
                    physics->velocityY += 9.8f * deltaTime;
                }
            }
        }
    };
    
    // 렌더링 시스템
    class RenderSystem : public ISystem {
    public:
        void update(float deltaTime, std::vector<Entity*>& entities) override {
            for (auto* entity : entities) {
                // Transform과 Sprite 컴포넌트가 있는 엔티티만 렌더링
                if (entity->hasComponent<TransformComponent>() &&
                    entity->hasComponent<SpriteComponent>()) {
                    
                    auto* transform = entity->getComponent<TransformComponent>();
                    auto* sprite = entity->getComponent<SpriteComponent>();
                    
                    std::cout << "Rendering entity " << entity->getId() 
                              << " at (" << transform->x << ", " << transform->y << ")"
                              << std::endl;
                }
            }
        }
    };
    
    // 체력 시스템
    class HealthSystem : public ISystem {
    public:
        void update(float deltaTime, std::vector<Entity*>& entities) override {
            for (auto* entity : entities) {
                if (entity->hasComponent<HealthComponent>()) {
                    auto* health = entity->getComponent<HealthComponent>();
                    
                    // 체력이 0 이하면 엔티티 제거 (실제로는 삭제 플래그 설정)
                    if (health->current <= 0) {
                        std::cout << "Entity " << entity->getId() 
                                  << " has died!" << std::endl;
                    }
                }
            }
        }
    };
}

// ============ World (엔티티 관리자) ============
namespace ECS {
    class World {
    private:
        std::vector<std::unique_ptr<Entity>> entities;
        std::vector<std::unique_ptr<ISystem>> systems;
        int nextEntityId = 0;
        
    public:
        Entity* createEntity() {
            auto entity = std::make_unique<Entity>(nextEntityId++);
            Entity* ptr = entity.get();
            entities.push_back(std::move(entity));
            return ptr;
        }
        
        void addSystem(std::unique_ptr<ISystem> system) {
            systems.push_back(std::move(system));
        }
        
        void update(float deltaTime) {
            // 모든 엔티티 포인터 수집
            std::vector<Entity*> entityPtrs;
            for (auto& entity : entities) {
                entityPtrs.push_back(entity.get());
            }
            
            // 각 시스템 업데이트
            for (auto& system : systems) {
                system->update(deltaTime, entityPtrs);
            }
        }
    };
}

// ============ Main ============
int main() {
    ECS::World world;
    
    // 시스템 추가
    world.addSystem(std::make_unique<ECS::PhysicsSystem>());
    world.addSystem(std::make_unique<ECS::RenderSystem>());
    world.addSystem(std::make_unique<ECS::HealthSystem>());
    
    // 플레이어 엔티티 생성
    auto* player = world.createEntity();
    auto* playerTransform = player->addComponent<ECS::TransformComponent>();
    playerTransform->x = 100.0f;
    playerTransform->y = 200.0f;
    
    auto* playerSprite = player->addComponent<ECS::SpriteComponent>();
    playerSprite->texturePath = "player.png";
    
    auto* playerPhysics = player->addComponent<ECS::PhysicsComponent>();
    playerPhysics->velocityX = 5.0f;
    
    auto* playerHealth = player->addComponent<ECS::HealthComponent>();
    playerHealth->current = 100.0f;
    
    // 적 엔티티 생성 (물리 없음)
    auto* enemy = world.createEntity();
    auto* enemyTransform = enemy->addComponent<ECS::TransformComponent>();
    enemyTransform->x = 300.0f;
    enemyTransform->y = 200.0f;
    
    auto* enemySprite = enemy->addComponent<ECS::SpriteComponent>();
    enemySprite->texturePath = "enemy.png";
    
    auto* enemyHealth = enemy->addComponent<ECS::HealthComponent>();
    enemyHealth->current = 50.0f;
    
    // 게임 루프 시뮬레이션
    std::cout << "=== Frame 1 ===" << std::endl;
    world.update(0.016f);  // 60 FPS
    
    std::cout << "\n=== Frame 2 ===" << std::endl;
    world.update(0.016f);
    
    return 0;
}

// ❌ 나쁜 예: 헤더에서 모든 것을 include
// Widget.h
#include "HeavyClass1.h"
#include "HeavyClass2.h"
#include "HeavyClass3.h"

class Widget {
private:
    HeavyClass1 obj1;
    HeavyClass2 obj2;
    HeavyClass3 obj3;
};

// ✅ 좋은 예: 전방 선언 + Pimpl
// Widget.h
class Widget {
private:
    class Impl;
    std::unique_ptr<Impl> pImpl;
public:
    Widget();
    ~Widget();
};

// Widget.cpp에서만 include
#include "Widget.h"
#include "HeavyClass1.h"
#include "HeavyClass2.h"
#include "HeavyClass3.h"

class Widget::Impl {
    HeavyClass1 obj1;
    HeavyClass2 obj2;
    HeavyClass3 obj3;
};

// pch.h - 자주 쓰이지만 거의 변경되지 않는 헤더들
#ifndef PCH_H
#define PCH_H

// 표준 라이브러리
#include <iostream>
#include <vector>
#include <string>
#include <memory>
#include <algorithm>
#include <unordered_map>

// 서드파티 라이브러리
#include <boost/filesystem.hpp>
#include <fmt/format.h>

// 프로젝트 공통 헤더
#include "Common/Types.h"
#include "Common/Macros.h"

#endif // PCH_H

# CMakeLists.txt - PCH 설정
target_precompile_headers(MyProject PRIVATE pch.h)

# CMakeLists.txt - Unity Build 활성화
set_target_properties(MyProject PROPERTIES
    UNITY_BUILD ON
    UNITY_BUILD_BATCH_SIZE 16
)

# 이렇게 하면 여러 .cpp 파일을 하나로 합쳐서 컴파일
# 컴파일 시간이 크게 단축되지만, 증분 빌드는 느려질 수 있음

// 가상 함수는 편리하지만 오버헤드가 있어
class Base {
public:
    virtual void process() = 0;  // 가상 함수 테이블 조회 필요
};

// 성능이 중요한 경우 CRTP (Curiously Recurring Template Pattern) 사용
template<typename Derived>
class Base {
public:
    void process() {
        static_cast<Derived*>(this)->processImpl();
    }
};

class Derived : public Base<Derived> {
public:
    void processImpl() {
        // 실제 구현
        // 컴파일 타임에 결정되므로 가상 함수 오버헤드 없음!
    }
};

// 사용
template<typename T>
void doWork(Base<T>& obj) {
    obj.process();  // 인라인 가능!
}

// ❌ 나쁜 예: 빈번한 동적 할당
void processData() {
    for (int i = 0; i < 1000000; ++i) {
        auto data = std::make_unique<Data>();  // 매번 new!
        data->process();
    }
}

// ✅ 좋은 예: 객체 풀 사용
template<typename T>
class ObjectPool {
private:
    std::vector<std::unique_ptr<T>> pool;
    std::vector<T*> available;
    
public:
    ObjectPool(size_t initialSize) {
        pool.reserve(initialSize);
        available.reserve(initialSize);
        
        for (size_t i = 0; i < initialSize; ++i) {
            pool.push_back(std::make_unique<T>());
            available.push_back(pool.back().get());
        }
    }
    
    T* acquire() {
        if (available.empty()) {
            pool.push_back(std::make_unique<T>());
            return pool.back().get();
        }
        
        T* obj = available.back();
        available.pop_back();
        return obj;
    }
    
    void release(T* obj) {
        available.push_back(obj);
    }
};

// 사용
void processData() {
    ObjectPool<Data> pool(1000);
    
    for (int i = 0; i < 1000000; ++i) {
        Data* data = pool.acquire();  // 재사용!
        data->process();
        pool.release(data);
    }
}

// ❌ 나쁜 예: 캐시 미스가 많은 구조
struct Entity {
    int id;
    std::string name;
    Vector3 position;
    Vector3 velocity;
    Mesh* mesh;
    Material* material;
    // ... 많은 데이터
};

std::vector<Entity> entities;  // 각 Entity가 메모리에 흩어져 있음

void updatePhysics() {
    for (auto& entity : entities) {
        entity.position += entity.velocity;  // 캐시 미스 발생!
    }
}

// ✅ 좋은 예: 데이터 지향 설계 (Data-Oriented Design)
struct PhysicsData {
    std::vector<Vector3> positions;
    std::vector<Vector3> velocities;
};

PhysicsData physicsData;

void updatePhysics() {
    // 연속된 메모리 접근으로 캐시 효율 극대화!
    for (size_t i = 0; i < physicsData.positions.size(); ++i) {
        physicsData.positions[i] += physicsData.velocities[i];
    }
    
    // SIMD 명령어로 더욱 최적화 가능
}

// 작업 큐 기반 스레드 풀
class ThreadPool {
private:
    std::vector<std::thread> workers;
    std::queue<std::function<void()>> tasks;
    std::mutex queueMutex;
    std::condition_variable condition;
    bool stop = false;
    
public:
    ThreadPool(size_t numThreads) {
        for (size_t i = 0; i < numThreads; ++i) {
            workers.emplace_back([this] {
                while (true) {
                    std::function<void()> task;
                    
                    {
                        std::unique_lock<std::mutex> lock(queueMutex);
                        condition.wait(lock, [this] {
                            return stop || !tasks.empty();
                        });
                        
                        if (stop && tasks.empty()) {
                            return;
                        }
                        
                        task = std::move(tasks.front());
                        tasks.pop();
                    }
                    
                    task();
                }
            });
        }
    }
    
    template<typename F>
    void enqueue(F&& f) {
        {
            std::unique_lock<std::mutex> lock(queueMutex);
            tasks.emplace(std::forward<F>(f));
        }
        condition.notify_one();
    }
    
    ~ThreadPool() {
        {
            std::unique_lock<std::mutex> lock(queueMutex);
            stop = true;
        }
        condition.notify_all();
        
        for (auto& worker : workers) {
            worker.join();
        }
    }
};

// 사용 예시
void parallelProcessing() {
    ThreadPool pool(std::thread::hardware_concurrency());
    
    std::vector<int> data(1000000);
    std::iota(data.begin(), data.end(), 0);
    
    const size_t chunkSize = data.size() / pool.numThreads();
    std::vector<std::future<long long>> futures;
    
    for (size_t i = 0; i < pool.numThreads(); ++i) {
        size_t start = i * chunkSize;
        size_t end = (i == pool.numThreads() - 1) ? data.size() : (i + 1) * chunkSize;
        
        futures.push_back(std::async(std::launch::async, [&data, start, end]() {
            long long sum = 0;
            for (size_t j = start; j < end; ++j) {
                sum += data[j] * data[j];
            }
            return sum;
        }));
    }
    
    long long totalSum = 0;
    for (auto& future : futures) {
        totalSum += future.get();
    }
    
    std::cout << "Total sum: " << totalSum << std::endl;
}

// Lock-Free 큐 (단순화된 버전)
template<typename T>
class LockFreeQueue {
private:
    struct Node {
        T data;
        std::atomic<Node*> next;
        Node(const T& data) : data(data), next(nullptr) {}
    };
    
    std::atomic<Node*> head;
    std::atomic<Node*> tail;
    
public:
    LockFreeQueue() {
        Node* dummy = new Node(T());
        head.store(dummy);
        tail.store(dummy);
    }
    
    void enqueue(const T& data) {
        Node* newNode = new Node(data);
        Node* oldTail;
        
        while (true) {
            oldTail = tail.load();
            Node* next = oldTail->next.load();
            
            if (oldTail == tail.load()) {
                if (next == nullptr) {
                    if (oldTail->next.compare_exchange_weak(next, newNode)) {
                        break;
                    }
                } else {
                    tail.compare_exchange_weak(oldTail, next);
                }
            }
        }
        
        tail.compare_exchange_weak(oldTail, newNode);
    }
    
    bool dequeue(T& result) {
        Node* oldHead;
        
        while (true) {
            oldHead = head.load();
            Node* oldTail = tail.load();
            Node* next = oldHead->next.load();
            
            if (oldHead == head.load()) {
                if (oldHead == oldTail) {
                    if (next == nullptr) {
                        return false;  // 큐가 비어있음
                    }
                    tail.compare_exchange_weak(oldTail, next);
                } else {
                    result = next->data;
                    if (head.compare_exchange_weak(oldHead, next)) {
                        break;
                    }
                }
            }
        }
        
        delete oldHead;
        return true;
    }
};

// 멀티스레드 환경에서 뮤텍스 없이 안전하게 사용 가능!
LockFreeQueue<Task> taskQueue;

// Producer 스레드
void producer() {
    for (int i = 0; i < 1000; ++i) {
        taskQueue.enqueue(Task{i});
    }
}

// Consumer 스레드
void consumer() {
    Task task;
    while (taskQueue.dequeue(task)) {
        task.execute();
    }
}

# 프로젝트 구조
MyProject/
├── CMakeLists.txt              # 루트 CMake
├── cmake/
│   └── modules/
│       └── FindCustomLib.cmake
├── src/
│   ├── CMakeLists.txt
│   ├── core/
│   │   ├── CMakeLists.txt
│   │   ├── Engine.h
│   │   └── Engine.cpp
│   ├── graphics/
│   │   ├── CMakeLists.txt
│   │   ├── Renderer.h
│   │   └── Renderer.cpp
│   └── audio/
│       ├── CMakeLists.txt
│       ├── AudioEngine.h
│       └── AudioEngine.cpp
├── tests/
│   ├── CMakeLists.txt
│   └── CoreTests.cpp
└── external/
    └── CMakeLists.txt

# 루트 CMakeLists.txt
cmake_minimum_required(VERSION 3.20)
project(MyProject VERSION 1.0.0 LANGUAGES CXX)

# C++ 표준 설정
set(CMAKE_CXX_STANDARD 20)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CXX_EXTENSIONS OFF)

# 빌드 타입별 컴파일 옵션
if(MSVC)
    add_compile_options(/W4 /WX)
    if(CMAKE_BUILD_TYPE STREQUAL "Release")
        add_compile_options(/O2)
    endif()
else()
    add_compile_options(-Wall -Wextra -Wpedantic -Werror)
    if(CMAKE_BUILD_TYPE STREQUAL "Release")
        add_compile_options(-O3)
    endif()
endif()

# 모듈 경로 추가
list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/modules")

# 서브디렉토리 추가
add_subdirectory(external)
add_subdirectory(src)

# 테스트 활성화
enable_testing()
add_subdirectory(tests)

# src/core/CMakeLists.txt
add_library(Core STATIC
    Engine.cpp
    Engine.h
    Logger.cpp
    Logger.h
)

# 인터페이스 헤더 경로 설정
target_include_directories(Core
    PUBLIC
        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/..>
        $<INSTALL_INTERFACE:include>
)

# 다른 모듈에 대한 의존성
target_link_libraries(Core
    PUBLIC
        Graphics
        Audio
)

# 컴파일 옵션
target_compile_features(Core PUBLIC cxx_std_20)

# src/graphics/CMakeLists.txt
add_library(Graphics STATIC
    Renderer.cpp
    Renderer.h
    Shader.cpp
    Shader.h
)

target_include_directories(Graphics
    PUBLIC
        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/..>
        $<INSTALL_INTERFACE:include>
)

# 외부 라이브러리 링크
find_package(OpenGL REQUIRED)
target_link_libraries(Graphics
    PUBLIC
        OpenGL::GL
)

LargeProject/
├── .github/                    # GitHub Actions CI/CD
│   └── workflows/
│       └── ci.yml
├── cmake/                      # CMake 모듈 및 스크립트
│   ├── modules/
│   └── toolchains/
├── docs/                       # 문서
│   ├── api/
│   └── guides/
├── include/                    # 공개 헤더 파일
│   └── myproject/
│       ├── core/
│       ├── graphics/
│       └── audio/
├── src/                        # 구현 파일
│   ├── core/
│   │   ├── CMakeLists.txt
│   │   ├── private/          # 내부 헤더
│   │   └── *.cpp
│   ├── graphics/
│   └── audio/
├── tests/                      # 단위 테스트
│   ├── unit/
│   ├── integration/
│   └── performance/
├── examples/                   # 예제 코드
│   ├── basic/
│   └── advanced/
├── tools/                      # 개발 도구
│   ├── code_generator/
│   └── asset_processor/
├── external/                   # 외부 라이브러리
│   ├── CMakeLists.txt
│   └── vendor/
├── scripts/                    # 빌드/배포 스크립트
│   ├── build.sh
│   └── deploy.sh
├── .clang-format              # 코드 포맷팅 규칙
├── .clang-tidy                # 정적 분석 규칙
├── CMakeLists.txt             # 루트 CMake
├── CMakePresets.json          # CMake 프리셋
├── conanfile.txt              # Conan 의존성
└── README.md

# .github/workflows/ci.yml
name: CI

on:
  push:
    branches: [ main, develop ]
  pull_request:
    branches: [ main, develop ]

jobs:
  build-linux:
    runs-on: ubuntu-latest
    
    steps:
    - uses: actions/checkout@v3
    
    - name: Install dependencies
      run: |
        sudo apt-get update
        sudo apt-get install -y cmake ninja-build
    
    - name: Configure CMake
      run: cmake -B build -G Ninja -DCMAKE_BUILD_TYPE=Release
    
    - name: Build
      run: cmake --build build --config Release
    
    - name: Run tests
      run: ctest --test-dir build --output-on-failure
  
  build-windows:
    runs-on: windows-latest
    
    steps:
    - uses: actions/checkout@v3
    
    - name: Configure CMake
      run: cmake -B build -DCMAKE_BUILD_TYPE=Release
    
    - name: Build
      run: cmake --build build --config Release
    
    - name: Run tests
      run: ctest --test-dir build --output-on-failure -C Release
  
  code-quality:
    runs-on: ubuntu-latest
    
    steps:
    - uses: actions/checkout@v3
    
    - name: Run clang-tidy
      run: |
        cmake -B build -DCMAKE_EXPORT_COMPILE_COMMANDS=ON
        clang-tidy src/**/*.cpp -p build
    
    - name: Run clang-format
      run: |
        find src include -name '*.cpp' -o -name '*.h' | xargs clang-format --dry-run --Werror

// Chromium 스타일의 컴포넌트 구조 예시
namespace content {

// 공개 API (content/public/browser/)
class CONTENT_EXPORT WebContents {
public:
    virtual ~WebContents() = default;
    virtual void LoadURL(const GURL& url) = 0;
    virtual RenderFrameHost* GetMainFrame() = 0;
    
    // 팩토리 메서드
    static std::unique_ptr<WebContents> Create(
        const CreateParams& params);
};

// 내부 구현 (content/browser/)
class WebContentsImpl : public WebContents {
private:
    std::unique_ptr<NavigationController> controller_;
    std::unique_ptr<RenderFrameHostManager> frame_manager_;
    
public:
    void LoadURL(const GURL& url) override {
        controller_->LoadURL(url);
    }
    
    RenderFrameHost* GetMainFrame() override {
        return frame_manager_->GetMainFrame();
    }
};

}  // namespace content

// Unreal Engine 스타일의 모듈 정의
// MyGameModule.h
#pragma once

#include "CoreMinimal.h"
#include "Modules/ModuleManager.h"

class FMyGameModule : public IModuleInterface
{
public:
    // 모듈 시작 시 호출
    virtual void StartupModule() override;
    
    // 모듈 종료 시 호출
    virtual void ShutdownModule() override;
};

// MyGameModule.cpp
#include "MyGameModule.h"

void FMyGameModule::StartupModule()
{
    UE_LOG(LogTemp, Log, TEXT("MyGame Module Started"));
    
    // 모듈 초기화 코드
}

void FMyGameModule::ShutdownModule()
{
    UE_LOG(LogTemp, Log, TEXT("MyGame Module Shutdown"));
    
    // 정리 코드
}

// 모듈 등록
IMPLEMENT_MODULE(FMyGameModule, MyGame)

// 게임 오브젝트 정의 (리플렉션 활용)
UCLASS()
class MYGAME_API AMyCharacter : public ACharacter
{
    GENERATED_BODY()
    
public:
    // 블루프린트에서 접근 가능
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Stats")
    float Health;
    
    // 블루프린트에서 호출 가능
    UFUNCTION(BlueprintCallable, Category = "Actions")
    void TakeDamage(float Damage);
    
protected:
    virtual void BeginPlay() override;
    virtual void Tick(float DeltaTime) override;
};

// LLVM 스타일의 Pass 구현
#include "llvm/Pass.h"
#include "llvm/IR/Function.h"
#include "llvm/Support/raw_ostream.h"

namespace {
    // 함수 정보를 출력하는 간단한 Pass
    struct FunctionInfoPass : public llvm::FunctionPass {
        static char ID;
        FunctionInfoPass() : FunctionPass(ID) {}
        
        bool runOnFunction(llvm::Function &F) override {
            llvm::errs() << "Function: " << F.getName() << "\n";
            llvm::errs() << "  Basic Blocks: " << F.size() << "\n";
            
            unsigned InstCount = 0;
            for (auto &BB : F) {
                InstCount += BB.size();
            }
            llvm::errs() << "  Instructions: " << InstCount << "\n";
            
            return false;  // 함수를 수정하지 않음
        }
    };
}

char FunctionInfoPass::ID = 0;

// Pass 등록
static llvm::RegisterPass<FunctionInfoPass> X(
    "function-info",
    "Function Information Pass",
    false,  // CFG를 수정하지 않음
    true    // 분석 Pass
);

// 리팩토링 단계별 접근

// 1단계: 테스트 코드 작성 (기존 동작 보존 확인)
TEST(LegacyCodeTest, ExistingBehavior) {
    LegacyClass obj;
    EXPECT_EQ(obj.calculate(10), 100);
}

// 2단계: 인터페이스 추출
class ICalculator {
public:
    virtual ~ICalculator() = default;
    virtual int calculate(int input) = 0;
};

class LegacyClass : public ICalculator {
    // 기존 코드 유지
    int calculate(int input) override {
        return input * 10;  // 레거시 로직
    }
};

// 3단계: 새로운 구현 작성
class ModernCalculator : public ICalculator {
    int calculate(int input) override {
        // 개선된 로직
        return input * input;
    }
};

// 4단계: 점진적 교체 (Feature Flag 활용)
class CalculatorFactory {
public:
    static std::unique_ptr<ICalculator> create() {
        if (FeatureFlags::useModernCalculator()) {
            return std::make_unique<ModernCalculator>();
        }
        return std::make_unique<LegacyClass>();
    }
};

// 5단계: 모니터링 후 완전 교체
// 새 구현이 안정적이면 레거시 코드 제거

/**
 * @file AudioEngine.h
 * @brief 오디오 재생 및 믹싱을 담당하는 핵심 엔진
 * 
 * AudioEngine은 게임의 모든 오디오 재생을 관리합니다.
 * 
 * 주요 기능:
 * - 3D 공간 오디오 재생
 * - 실시간 믹싱 및 이펙트 처리
 * - 스트리밍 및 메모리 관리
 * 
 * 사용 예시:
 * @code
 * AudioEngine engine;
 * engine.initialize();
 * 
 * auto sound = engine.loadSound("explosion.wav");
 * engine.playSound(sound, position, volume);
 * @endcode
 * 
 * @note 이 클래스는 싱글톤 패턴을 사용합니다.
 * @warning 멀티스레드 환경에서 사용 시 주의가 필요합니다.
 * 
 * @see AudioSource
 * @see AudioMixer
 */
class AudioEngine {
public:
    /**
     * @brief 오디오 엔진을 초기화합니다.
     * 
     * @param sampleRate 샘플링 레이트 (기본값: 44100Hz)
     * @param channels 채널 수 (기본값: 2 - 스테레오)
     * @return 초기화 성공 여부
     * 
     * @throws AudioException 오디오 디바이스를 열 수 없는 경우
     */
    bool initialize(int sampleRate = 44100, int channels = 2);
    
    /**
     * @brief 사운드 파일을 로드합니다.
     * 
     * @param filepath 사운드 파일 경로
     * @return 로드된 사운드 핸들
     * 
     * @pre filepath는 유효한 경로여야 함
     * @post 반환된 핸들은 playSound()에서 사용 가능
     */
    SoundHandle loadSound(const std::string& filepath);
};

// 간단한 프로파일링 유틸리티
class ScopedTimer {
private:
    std::string name;
    std::chrono::high_resolution_clock::time_point start;
    
public:
    ScopedTimer(const std::string& name) 
        : name(name), start(std::chrono::high_resolution_clock::now()) {}
    
    ~ScopedTimer() {
        auto end = std::chrono::high_resolution_clock::now();
        auto duration = std::chrono::duration_cast<std::chrono::microseconds>(end - start);
        std::cout << name << " took " << duration.count() << " μs" << std::endl;
    }
};

// 사용
void expensiveFunction() {
    ScopedTimer timer("expensiveFunction");
    
    // 시간이 오래 걸리는 작업
    for (int i = 0; i < 1000000; ++i) {
        // ...
    }
}  // 소멸자에서 자동으로 시간 출력

// 더 정교한 프로파일링
class Profiler {
private:
    struct ProfileData {
        std::string name;
        long long totalTime = 0;
        int callCount = 0;
    };
    
    std::unordered_map<std::string, ProfileData> data;
    std::mutex mutex;
    
public:
    static Profiler& instance() {
        static Profiler inst;
        return inst;
    }
    
    void recordTime(const std::string& name, long long microseconds) {
        std::lock_guard<std::mutex> lock(mutex);
        auto& profile = data[name];
        profile.name = name;
        profile.totalTime += microseconds;
        profile.callCount++;
    }
    
    void printReport() {
        std::cout << "\n=== Profiling Report ===\n";
        for (const auto& [name, profile] : data) {
            double avgTime = static_cast<double>(profile.totalTime) / profile.callCount;
            std::cout << name << ":\n"
                      << "  Total: " << profile.totalTime << " μs\n"
                      << "  Calls: " << profile.callCount << "\n"
                      << "  Average: " << avgTime << " μs\n";
        }
    }
};

#define PROFILE_SCOPE(name) \
    ScopedTimer _timer_##__LINE__(name); \
    auto _cleanup_##__LINE__ = [&]() { \
        Profiler::instance().recordTime(name, \
            std::chrono::duration_cast<std::chrono::microseconds>( \
                std::chrono::high_resolution_clock::now() - _timer_##__LINE__.start \
            ).count()); \
    };

// C++23 std::expected 예시
#include <expected>
#include <string>

enum class ErrorCode {
    FileNotFound,
    PermissionDenied,
    InvalidFormat
};

std::expected<std::string, ErrorCode> readFile(const std::string& path) {
    if (!fileExists(path)) {
        return std::unexpected(ErrorCode::FileNotFound);
    }
    
    if (!hasPermission(path)) {
        return std::unexpected(ErrorCode::PermissionDenied);
    }
    
    return readFileContent(path);
}

// 사용
auto result = readFile("config.txt");
if (result) {
    std::cout << "Content: " << *result << std::endl;
} else {
    switch (result.error()) {
        case ErrorCode::FileNotFound:
            std::cerr << "File not found" << std::endl;
            break;
        case ErrorCode::PermissionDenied:
            std::cerr << "Permission denied" << std::endl;
            break;
        default:
            std::cerr << "Unknown error" << std::endl;
    }
}

// 미래의 C++ 패키지 관리 (가상의 예시)
// package.cpp
module;

import std;
import boost.asio;
import fmt;

export module myproject.networking;

export namespace myproject {
    class NetworkClient {
        // 구현
    };
}

# Dockerfile - 멀티스테이지 빌드
# 빌드 스테이지
FROM gcc:12 AS builder

WORKDIR /app
COPY . .

RUN cmake -B build -DCMAKE_BUILD_TYPE=Release && \
    cmake --build build --config Release

# 실행 스테이지
FROM ubuntu:22.04

# 필요한 런타임 라이브러리만 복사
COPY --from=builder /app/build/myapp /usr/local/bin/

# 실행
CMD ["myapp"]