🎯 C++20 모듈, 도대체 뭐가 다른 거야?

자, 먼저 기본부터 짚고 넘어가자. C++20 이전까지는 코드를 재사용하려면 헤더 파일(.h)과 구현 파일(.cpp)로 나눠서 작성했어. 그리고 필요한 곳에서 #include로 가져다 썼지.

문제는 이 방식이 텍스트 기반 복사-붙여넣기라는 거야. 컴파일러는 #include를 만나면 그냥 해당 파일의 내용을 통째로 복사해서 붙여넣어. 😅

상상해봐. 100개의 소스 파일이 같은 헤더를 include하면? 그 헤더의 내용이 100번 파싱되고, 100번 컴파일돼. 엄청난 낭비지!

🎭 3단계: 인터페이스와 구현 분리

모듈에서도 인터페이스와 구현을 분리할 수 있어. 이건 컴파일 시간을 더욱 줄이는 강력한 기법이야!

// Database.cppm
export module GameEngine.Database;

import std;  // 표준 라이브러리 모듈

export class DatabaseConnection {
public:
    DatabaseConnection(std::string_view connectionString);
    ~DatabaseConnection();
    
    bool connect();
    void disconnect();
    
    std::vector<std::string> executeQuery(std::string_view query);
    bool executeCommand(std::string_view command);
    
private:
    struct Impl;  // Pimpl 패턴
    std::unique_ptr<Impl> pImpl;
};

// Database_impl.cpp
module GameEngine.Database;  // export 없음! 구현 유닛

import ThirdParty.SQLite;  // 외부 라이브러리

struct DatabaseConnection::Impl {
    sqlite3* db;
    std::string connectionString;
    bool isConnected;
    
    Impl(std::string_view connStr) 
        : db(nullptr), connectionString(connStr), isConnected(false) {}
};

DatabaseConnection::DatabaseConnection(std::string_view connectionString)
    : pImpl(std::make_unique<Impl>(connectionString)) {}

DatabaseConnection::~DatabaseConnection() {
    if (pImpl->isConnected) {
        disconnect();
    }
}

bool DatabaseConnection::connect() {
    int result = sqlite3_open(pImpl->connectionString.c_str(), &pImpl->db);
    pImpl->isConnected = (result == SQLITE_OK);
    return pImpl->isConnected;
}

// ... 나머지 구현

🎯 실전 프로젝트 예제: 게임 엔진 구조

이론은 충분히 배웠으니, 이제 실제 게임 엔진 프로젝트를 모듈로 구조화하는 완전한 예제를 보자! 🎮

GameEngine/
├── Core/
│   ├── Math/
│   │   ├── Vector.cppm
│   │   ├── Matrix.cppm
│   │   ├── Quaternion.cppm
│   │   └── Math.cppm
│   ├── Memory/
│   │   ├── Allocator.cppm
│   │   ├── Pool.cppm
│   │   └── Memory.cppm
│   └── Core.cppm
│
├── Graphics/
│   ├── Renderer.cppm
│   ├── Shader.cppm
│   ├── Texture.cppm
│   ├── Mesh.cppm
│   └── Graphics.cppm
│
├── Physics/
│   ├── RigidBody.cppm
│   ├── Collision.cppm
│   ├── Constraint.cppm
│   └── Physics.cppm
│
├── Audio/
│   ├── SoundEngine.cppm
│   ├── Music.cppm
│   └── Audio.cppm
│
├── Input/
│   ├── Keyboard.cppm
│   ├── Mouse.cppm
│   └── Input.cppm
│
└── Engine.cppm

export module GameEngine.Core.Math:Vector;

import std;

export namespace GameEngine::Math {
    
    class Vector3 {
    public:
        float x, y, z;
        
        constexpr Vector3(float x = 0, float y = 0, float z = 0) noexcept
            : x(x), y(y), z(z) {}
        
        // 연산자 오버로딩
        constexpr Vector3 operator+(const Vector3& other) const noexcept {
            return Vector3(x + other.x, y + other.y, z + other.z);
        }
        
        constexpr Vector3 operator-(const Vector3& other) const noexcept {
            return Vector3(x - other.x, y - other.y, z - other.z);
        }
        
        constexpr Vector3 operator*(float scalar) const noexcept {
            return Vector3(x * scalar, y * scalar, z * scalar);
        }
        
        // 벡터 연산
        [[nodiscard]] float length() const noexcept {
            return std::sqrt(x * x + y * y + z * z);
        }
        
        [[nodiscard]] float lengthSquared() const noexcept {
            return x * x + y * y + z * z;
        }
        
        [[nodiscard]] Vector3 normalized() const noexcept {
            float len = length();
            if (len > 0.0001f) {
                return *this * (1.0f / len);
            }
            return Vector3(0, 0, 0);
        }
        
        [[nodiscard]] float dot(const Vector3& other) const noexcept {
            return x * other.x + y * other.y + z * other.z;
        }
        
        [[nodiscard]] Vector3 cross(const Vector3& other) const noexcept {
            return Vector3(
                y * other.z - z * other.y,
                z * other.x - x * other.z,
                x * other.y - y * other.x
            );
        }
    };
    
    // 전역 연산자
    constexpr Vector3 operator*(float scalar, const Vector3& vec) noexcept {
        return vec * scalar;
    }
    
} // namespace GameEngine::Math

export module GameEngine.Core.Math;

// 파티션들을 재export
export import :Vector;
export import :Matrix;
export import :Quaternion;

export namespace GameEngine::Math {
    
    // 공통 수학 상수
    inline constexpr float PI = 3.14159265358979323846f;
    inline constexpr float TWO_PI = 2.0f * PI;
    inline constexpr float HALF_PI = 0.5f * PI;
    inline constexpr float DEG_TO_RAD = PI / 180.0f;
    inline constexpr float RAD_TO_DEG = 180.0f / PI;
    
    // 유틸리티 함수
    template<typename T>
    constexpr T clamp(T value, T min, T max) noexcept {
        return value < min ? min : (value > max ? max : value);
    }
    
    template<typename T>
    constexpr T lerp(T a, T b, float t) noexcept {
        return a + (b - a) * t;
    }
    
    constexpr float degrees(float radians) noexcept {
        return radians * RAD_TO_DEG;
    }
    
    constexpr float radians(float degrees) noexcept {
        return degrees * DEG_TO_RAD;
    }
    
} // namespace GameEngine::Math

export module GameEngine.Graphics:Renderer;

import GameEngine.Core.Math;
import std;

export namespace GameEngine::Graphics {
    
    // 전방 선언
    class Shader;
    class Texture;
    class Mesh;
    
    enum class RenderMode {
        Solid,
        Wireframe,
        Points
    };
    
    class Renderer {
    public:
        Renderer();
        ~Renderer();
        
        // 초기화 및 종료
        bool initialize(int width, int height);
        void shutdown();
        
        // 렌더링 제어
        void beginFrame();
        void endFrame();
        void clear(const Math::Vector3& color);
        
        // 렌더링 설정
        void setViewport(int x, int y, int width, int height);
        void setRenderMode(RenderMode mode);
        
        // 카메라 설정
        void setViewMatrix(const Math::Matrix4x4& view);
        void setProjectionMatrix(const Math::Matrix4x4& projection);
        
        // 렌더링
        void drawMesh(const Mesh& mesh, const Shader& shader);
        void drawMeshInstanced(const Mesh& mesh, const Shader& shader, int count);
        
        // 통계
        struct Statistics {
            uint32_t drawCalls;
            uint32_t triangles;
            uint32_t vertices;
            float frameTime;
        };
        
        [[nodiscard]] const Statistics& getStatistics() const noexcept {
            return stats;
        }
        
        void resetStatistics() noexcept {
            stats = Statistics{};
        }
        
    private:
        struct Impl;
        std::unique_ptr<Impl> pImpl;
        
        Statistics stats;
        RenderMode currentMode;
    };
    
} // namespace GameEngine::Graphics

export module GameEngine;

// 모든 서브시스템 export
export import GameEngine.Core;
export import GameEngine.Graphics;
export import GameEngine.Physics;
export import GameEngine.Audio;
export import GameEngine.Input;

import std;

export namespace GameEngine {
    
    class Engine {
    public:
        static Engine& getInstance() {
            static Engine instance;
            return instance;
        }
        
        bool initialize();
        void shutdown();
        
        void run();
        void stop();
        
        [[nodiscard]] bool isRunning() const noexcept {
            return running;
        }
        
        // 서브시스템 접근
        [[nodiscard]] Graphics::Renderer& getRenderer() noexcept {
            return *renderer;
        }
        
        [[nodiscard]] Physics::PhysicsWorld& getPhysics() noexcept {
            return *physics;
        }
        
        [[nodiscard]] Audio::SoundEngine& getAudio() noexcept {
            return *audio;
        }
        
    private:
        Engine() = default;
        ~Engine() = default;
        
        Engine(const Engine&) = delete;
        Engine& operator=(const Engine&) = delete;
        
        bool running = false;
        
        std::unique_ptr<Graphics::Renderer> renderer;
        std::unique_ptr<Physics::PhysicsWorld> physics;
        std::unique_ptr<Audio::SoundEngine> audio;
    };
    
} // namespace GameEngine

import GameEngine;
import std;

int main() {
    using namespace GameEngine;
    
    // 엔진 초기화
    auto& engine = Engine::getInstance();
    if (!engine.initialize()) {
        std::cerr << "Failed to initialize engine\n";
        return 1;
    }
    
    // 렌더러 설정
    auto& renderer = engine.getRenderer();
    renderer.setRenderMode(Graphics::RenderMode::Solid);
    
    // 게임 오브젝트 생성
    Math::Vector3 position(0, 0, 0);
    Math::Vector3 velocity(1, 0, 0);
    
    // 메인 루프
    while (engine.isRunning()) {
        renderer.beginFrame();
        renderer.clear(Math::Vector3(0.1f, 0.1f, 0.15f));
        
        // 게임 로직
        position = position + velocity * 0.016f;  // 60 FPS 가정
        
        // 렌더링
        // ... 실제 렌더링 코드
        
        renderer.endFrame();
        
        // 통계 출력
        const auto& stats = renderer.getStatistics();
        if (stats.drawCalls > 0) {
            std::cout << std::format("Draw calls: {}, Triangles: {}, Frame time: {:.2f}ms\n",
                stats.drawCalls, stats.triangles, stats.frameTime);
        }
    }
    
    engine.shutdown();
    return 0;
}

이렇게 구조화하면 각 모듈이 명확한 책임을 가지고, 의존성도 깔끔하게 관리돼. 새로운 기능을 추가하거나 기존 코드를 수정할 때도 영향 범위가 최소화되지! 🎯

🎓 마무리하며

와, 여기까지 정말 긴 여정이었어! 🎉 C++20 모듈에 대해 기초부터 고급 기법까지 모두 살펴봤어.

핵심을 다시 한번 정리하자면:

1. 모듈은 컴파일 시간을 획기적으로 줄여줘
텍스트 기반 #include 대신 바이너리 인터페이스(BMI)를 사용하니까 훨씬 빨라!

2. 코드 구조가 명확해져
export로 공개 인터페이스를 명시하고, 내부 구현은 완벽하게 숨길 수 있어.

3. 의존성 관리가 쉬워져
순환 의존성 같은 골치 아픈 문제들이 자연스럽게 해결돼.

4. 대규모 프로젝트에 최적화돼 있어
계층적 구조, 파티션, 인터페이스/구현 분리 등으로 수십만 줄의 코드도 깔끔하게 관리 가능!

물론 아직 완벽하지는 않아. 컴파일러 지원이 계속 개선되고 있고, 빌드 시스템 통합도 발전 중이야. 하지만 방향은 확실해. 모듈은 C++의 미래야! 🚀

새 프로젝트를 시작한다면 주저 없이 모듈을 사용해봐. 기존 프로젝트라면 단계적으로 마이그레이션을 고려해볼 만해. 처음엔 낯설겠지만, 익숙해지면 다시는 옛날 방식으로 돌아가고 싶지 않을 거야! 😎

혹시 모듈 도입 과정에서 막히는 부분이 있다면, 재능넷에서 C++ 전문가들의 도움을 받는 것도 좋은 방법이야. 경험 많은 개발자의 조언 한마디가 며칠간의 삽질을 줄여줄 수 있거든!

자, 이제 당신의 프로젝트에 모듈을 적용해볼 시간이야. 행운을 빌어! 화이팅! 💪✨