[2026] C++ Policy-Based Design | 정책 기반 설계 가이드

2026년 3월 12일 · 13분 읽기 · 수정 2026년 3월 12일 고급 튜토리얼

이 글의 핵심

C++ Policy-Based Design - 정책 기반 설계 가이드. C++ Policy-Based Design의 여러 정책 조합, 실전 예시, 정책 조합를 실전 코드와 함께 설명합니다.

Policy-Based Design이란?

템플릿 매개변수로 정책(Policy) 클래스를 전달하여 동작을 커스터마이징 다음은 cpp를 활용한 상세한 구현 코드입니다. 클래스를 정의하여 데이터와 기능을 캡슐화하며. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

// 정책 클래스
struct NoLocking {
    void lock() {}
    void unlock() {}
};
struct MutexLocking {
    mutex mtx;
    void lock() { mtx.lock(); }
    void unlock() { mtx.unlock(); }
};
// 정책 기반 클래스
template<typename LockingPolicy>
class Counter {
private:
    int value = 0;
    LockingPolicy lockPolicy;
    
public:
    void increment() {
        lockPolicy.lock();
        value++;
        lockPolicy.unlock();
    }
    
    int get() {
        lockPolicy.lock();
        int result = value;
        lockPolicy.unlock();
        return result;
    }
};
int main() {
    Counter<NoLocking> singleThreaded;
    Counter<MutexLocking> multiThreaded;
    
    singleThreaded.increment();
    multiThreaded.increment();
}

여러 정책 조합

다음은 cpp를 활용한 상세한 구현 코드입니다. 필요한 모듈을 import하고, 클래스를 정의하여 데이터와 기능을 캡슐화하며, 조건문으로 분기 처리를 수행합니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

// 스레딩 정책
struct SingleThreaded {
    struct Lock {
        void lock() {}
        void unlock() {}
    };
};
struct MultiThreaded {
    struct Lock {
        mutex mtx;
        void lock() { mtx.lock(); }
        void unlock() { mtx.unlock(); }
    };
};
// 할당 정책
struct NewAllocator {
    template<typename T>
    static T* allocate() {
        return new T();
    }
    
    template<typename T>
    static void deallocate(T* ptr) {
        delete ptr;
    }
};
struct PoolAllocator {
    // 메모리 풀 구현
};
// 정책 기반 싱글톤
template<typename T, typename ThreadingPolicy, typename AllocPolicy>
class Singleton {
private:
    static T* instance;
    static typename ThreadingPolicy::Lock lock;
    
public:
    static T& getInstance() {
        if (!instance) {
            lock.lock();
            if (!instance) {
                instance = AllocPolicy::template allocate<T>();
            }
            lock.unlock();
        }
        return *instance;
    }
};
template<typename T, typename TP, typename AP>
T* Singleton<T, TP, AP>::instance = nullptr;
// 사용
using MySingleton = Singleton<Config, MultiThreaded, NewAllocator>;

실전 예시

예시 1: 스마트 포인터

// 소유권 정책
struct RefCounted {
    int* count;
    
    RefCounted() : count(new int(1)) {}
    
    void acquire() { (*count)++; }
    
    void release() {
        if (--(*count) == 0) {
            delete count;
        }
    }
    
    int getCount() { return *count; }
};
struct DestructiveCopy {
    void acquire() {}
    void release() {}
    int getCount() { return 1; }
};
// 체크 정책
struct NoCheck {
    template<typename T>
    static void check(T*) {}
};
struct AssertCheck {
    template<typename T>
    static void check(T* ptr) {
        assert(ptr != nullptr);
    }
};
// 정책 기반 스마트 포인터
template<typename T, typename OwnershipPolicy, typename CheckingPolicy>
class SmartPtr {
private:
    T* ptr;
    OwnershipPolicy ownership;
    
public:
    SmartPtr(T* p) : ptr(p) {}
    
    T& operator*() {
        CheckingPolicy::check(ptr);
        return *ptr;
    }
    
    T* operator->() {
        CheckingPolicy::check(ptr);
        return ptr;
    }
    
    SmartPtr(const SmartPtr& other) : ptr(other.ptr) {
        ownership.acquire();
    }
    
    ~SmartPtr() {
        ownership.release();
    }
};
using SharedPtr = SmartPtr<Widget, RefCounted, AssertCheck>;
using UniquePtr = SmartPtr<Widget, DestructiveCopy, NoCheck>;

예시 2: 로거

다음은 cpp를 활용한 상세한 구현 코드입니다. 클래스를 정의하여 데이터와 기능을 캡슐화하며. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

// 출력 정책
struct ConsoleOutput {
    void write(const string& msg) {
        cout << msg << endl;
    }
};
struct FileOutput {
    ofstream file;
    
    FileOutput() : file("log.txt", ios::app) {}
    
    void write(const string& msg) {
        file << msg << endl;
    }
};
// 포맷 정책
struct SimpleFormat {
    string format(const string& msg) {
        return msg;
    }
};
struct TimestampFormat {
    string format(const string& msg) {
        auto now = chrono::system_clock::now();
        auto time = chrono::system_clock::to_time_t(now);
        return string(ctime(&time)) + ": " + msg;
    }
};
// 정책 기반 로거
template<typename OutputPolicy, typename FormatPolicy>
class Logger : private OutputPolicy, private FormatPolicy {
public:
    void log(const string& msg) {
        string formatted = FormatPolicy::format(msg);
        OutputPolicy::write(formatted);
    }
};
int main() {
    Logger<ConsoleOutput, SimpleFormat> console;
    console.log("콘솔 로그");
    
    Logger<FileOutput, TimestampFormat> file;
    file.log("파일 로그");
}

예시 3: 컨테이너

다음은 cpp를 활용한 상세한 구현 코드입니다. 클래스를 정의하여 데이터와 기능을 캡슐화하며, 반복문으로 데이터를 처리합니다, 조건문으로 분기 처리를 수행합니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

// 성장 정책
struct DoubleGrowth {
    static size_t grow(size_t current) {
        return current * 2;
    }
};
struct LinearGrowth {
    static size_t grow(size_t current) {
        return current + 10;
    }
};
// 정책 기반 벡터
template<typename T, typename GrowthPolicy>
class Vector {
private:
    T* data;
    size_t size;
    size_t capacity;
    
public:
    Vector() : data(nullptr), size(0), capacity(0) {}
    
    void push_back(const T& value) {
        if (size == capacity) {
            size_t newCapacity = capacity == 0 ? 1 : GrowthPolicy::grow(capacity);
            T* newData = new T[newCapacity];
            
            for (size_t i = 0; i < size; i++) {
                newData[i] = data[i];
            }
            
            delete[] data;
            data = newData;
            capacity = newCapacity;
        }
        
        data[size++] = value;
    }
    
    size_t getCapacity() const { return capacity; }
};
int main() {
    Vector<int, DoubleGrowth> v1;
    Vector<int, LinearGrowth> v2;
    
    for (int i = 0; i < 100; i++) {
        v1.push_back(i);
        v2.push_back(i);
    }
    
    cout << "Double: " << v1.getCapacity() << endl;  // 128
    cout << "Linear: " << v2.getCapacity() << endl;  // 100
}

정책 조합

아래 코드는 cpp를 사용한 구현 예제입니다. 클래스를 정의하여 데이터와 기능을 캡슐화하며. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

template<
    typename T,
    typename ThreadingPolicy = SingleThreaded,
    typename AllocPolicy = NewAllocator,
    typename CheckingPolicy = NoCheck
>
class SmartContainer {
    // 모든 정책 조합 가능
};
// 사용
SmartContainer<int> simple;
SmartContainer<int, MultiThreaded> threadSafe;
SmartContainer<int, MultiThreaded, PoolAllocator> optimized;

자주 발생하는 문제

문제 1: 정책 인터페이스 불일치

아래 코드는 cpp를 사용한 구현 예제입니다. 클래스를 정의하여 데이터와 기능을 캡슐화하며. 코드를 직접 실행해보면서 동작을 확인해보세요.

// ❌ 인터페이스 불일치
struct BadPolicy {
    void doSomething() {}  // 다른 이름
};
// ✅ 명확한 인터페이스
struct GoodPolicy {
    void execute() {}  // 통일된 이름
};

문제 2: 정책 상태

아래 코드는 cpp를 사용한 구현 예제입니다. 클래스를 정의하여 데이터와 기능을 캡슐화하며. 코드를 직접 실행해보면서 동작을 확인해보세요.

// ❌ 정책에 상태 저장
struct StatefulPolicy {
    int state;  // 문제 발생 가능
};
// ✅ 상태 없는 정책
struct StatelessPolicy {
    static void execute() {}
};

문제 3: 복잡도 증가

// 너무 많은 정책은 복잡도 증가
template<typename P1, typename P2, typename P3, typename P4, typename P5>
class OverEngineered {
    // 유지보수 어려움
};
// 적절한 수준 유지
template<typename ThreadingPolicy, typename AllocPolicy>
class Reasonable {
    // 관리 가능
};

FAQ

Q1: Policy-Based Design은 언제 사용하나요?

라이브러리 개발
유연한 설계 필요
여러 동작 조합 필요

Q2: Strategy 패턴과 차이는?

Policy: 컴파일 타임, 오버헤드 없음
Strategy: 런타임, 가상 함수 오버헤드

Q3: 단점은?

코드 복잡도 증가
컴파일 시간 증가
에러 메시지 복잡

Q4: 정책은 몇 개가 적당한가요?

A: 2-4개 정도가 적당합니다. 너무 많으면 복잡해집니다.

Q5: 정책 변경은 런타임에 가능한가요?

A: 아니요. 컴파일 타임에 결정됩니다. 런타임 변경이 필요하면 Strategy 패턴을 사용하세요.

Q6: Policy-Based Design 학습 리소스는?

“Modern C++ Design” (Andrei Alexandrescu)
Loki 라이브러리
Boost 라이브러리 소스

같이 보면 좋은 글 (내부 링크)

이 주제와 연결되는 다른 글입니다.