[2026] C++ Memory Pool | 메모리 풀 가이드

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

이 글의 핵심

template<typename T, size_t N> class FixedPool { alignas(T) char buffer[N sizeof(T)]; std::vector<T> freeList;…

Memory Pool이란?

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

class MemoryPool {
    std::vector<void*> freeList;
    size_t blockSize;
    
public:
    MemoryPool(size_t size, size_t count) : blockSize(size) {
        for (size_t i = 0; i < count; ++i) {
            freeList.push_back(::operator new(blockSize));
        }
    }
    
    void* allocate() {
        if (freeList.empty()) {
            return ::operator new(blockSize);
        }
        void* ptr = freeList.back();
        freeList.pop_back();
        return ptr;
    }
    
    void deallocate(void* ptr) {
        freeList.push_back(ptr);
    }
};

기본 구조

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

template<typename T>
class ObjectPool {
    std::vector<T*> pool;
    std::vector<T*> available;
    
public:
    ObjectPool(size_t size) {
        pool.reserve(size);
        available.reserve(size);
        
        for (size_t i = 0; i < size; ++i) {
            T* obj = new T();
            pool.push_back(obj);
            available.push_back(obj);
        }
    }
    
    ~ObjectPool() {
        for (T* obj : pool) {
            delete obj;
        }
    }
    
    T* acquire() {
        if (available.empty()) {
            return nullptr;
        }
        T* obj = available.back();
        available.pop_back();
        return obj;
    }
    
    void release(T* obj) {
        available.push_back(obj);
    }
};

실전 예시

예시 1: 고정 크기 풀

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

template<typename T, size_t N>
class FixedPool {
    alignas(T) char buffer[N * sizeof(T)];
    std::vector<T*> freeList;
    
public:
    FixedPool() {
        for (size_t i = 0; i < N; ++i) {
            freeList.push_back(reinterpret_cast<T*>(&buffer[i * sizeof(T)]));
        }
    }
    
    T* allocate() {
        if (freeList.empty()) {
            throw std::bad_alloc();
        }
        T* ptr = freeList.back();
        freeList.pop_back();
        return new (ptr) T();  // placement new
    }
    
    void deallocate(T* ptr) {
        ptr->~T();  // 소멸자 호출
        freeList.push_back(ptr);
    }
};
int main() {
    FixedPool<int, 100> pool;
    
    int* p1 = pool.allocate();
    *p1 = 42;
    
    pool.deallocate(p1);
}

예시 2: 스레드 안전 풀

template<typename T>
class ThreadSafePool {
    std::vector<T*> pool;
    std::stack<T*> available;
    std::mutex mtx;
    
public:
    ThreadSafePool(size_t size) {
        pool.reserve(size);
        for (size_t i = 0; i < size; ++i) {
            T* obj = new T();
            pool.push_back(obj);
            available.push(obj);
        }
    }
    
    ~ThreadSafePool() {
        for (T* obj : pool) {
            delete obj;
        }
    }
    
    T* acquire() {
        std::lock_guard lock{mtx};
        if (available.empty()) {
            return nullptr;
        }
        T* obj = available.top();
        available.pop();
        return obj;
    }
    
    void release(T* obj) {
        std::lock_guard lock{mtx};
        available.push(obj);
    }
};

예시 3: RAII 래퍼

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

template<typename T>
class PoolPtr {
    ObjectPool<T>* pool;
    T* ptr;
    
public:
    PoolPtr(ObjectPool<T>* p) : pool(p), ptr(pool->acquire()) {}
    
    ~PoolPtr() {
        if (ptr) {
            pool->release(ptr);
        }
    }
    
    PoolPtr(const PoolPtr&) = delete;
    PoolPtr& operator=(const PoolPtr&) = delete;
    
    PoolPtr(PoolPtr&& other) noexcept 
        : pool(other.pool), ptr(other.ptr) {
        other.ptr = nullptr;
    }
    
    T* get() const { return ptr; }
    T& operator*() const { return *ptr; }
    T* operator->() const { return ptr; }
};
int main() {
    ObjectPool<std::string> pool(100);
    
    {
        PoolPtr<std::string> str{&pool};
        *str = "hello";
    }  // 자동 반환
}

예시 4: 가변 크기 풀

class VariableSizePool {
    struct Block {
        size_t size;
        void* data;
    };
    
    std::vector<Block> freeBlocks;
    
public:
    void* allocate(size_t size) {
        // 적합한 블록 찾기
        for (auto it = freeBlocks.begin(); it != freeBlocks.end(); ++it) {
            if (it->size >= size) {
                void* ptr = it->data;
                freeBlocks.erase(it);
                return ptr;
            }
        }
        
        // 새로 할당
        return ::operator new(size);
    }
    
    void deallocate(void* ptr, size_t size) {
        freeBlocks.push_back({size, ptr});
    }
};

장점

아래 코드는 cpp를 사용한 구현 예제입니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

// 1. 빠른 할당
// - 미리 할당
// - 시스템 호출 감소
// 2. 단편화 방지
// - 고정 크기 블록
// 3. 캐시 친화적
// - 연속 메모리
// 4. 예측 가능
// - 할당 실패 없음 (고정 풀)

자주 발생하는 문제

문제 1: 풀 크기

아래 코드는 cpp를 사용한 구현 예제입니다. 반복문으로 데이터를 처리합니다. 코드를 직접 실행해보면서 동작을 확인해보세요.

// ❌ 풀 부족
ObjectPool<T> pool(10);
for (int i = 0; i < 100; ++i) {
    T* obj = pool.acquire();  // nullptr 가능
}
// ✅ 충분한 크기 또는 동적 확장

문제 2: 메모리 누수

아래 코드는 cpp를 사용한 구현 예제입니다. 코드를 직접 실행해보면서 동작을 확인해보세요.

ObjectPool<T> pool(100);
T* obj = pool.acquire();
// ❌ release 누락
// 메모리 누수
// ✅ RAII
PoolPtr<T> obj{&pool};  // 자동 반환

문제 3: 스레드 안전

아래 코드는 cpp를 사용한 구현 예제입니다. 코드를 직접 실행해보면서 동작을 확인해보세요.

// ❌ 스레드 안전 아님
ObjectPool<T> pool(100);
std::thread t1([&]() { pool.acquire(); });
std::thread t2([&]() { pool.acquire(); });  // 레이스
// ✅ 뮤텍스 또는 스레드 로컬

문제 4: 소멸자

아래 코드는 cpp를 사용한 구현 예제입니다. 코드를 직접 실행해보면서 동작을 확인해보세요.

// 풀 반환 시 소멸자 호출 안 됨
T* obj = pool.acquire();
obj->~T();  // 명시적 호출 필요
pool.release(obj);
// 또는 reset 메서드

활용 패턴

아래 코드는 cpp를 사용한 구현 예제입니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

// 1. 고정 크기 객체
ObjectPool<GameObject> pool(1000);
// 2. 빈번한 할당/해제
auto obj = pool.acquire();
pool.release(obj);
// 3. RAII 래퍼
PoolPtr<T> obj{&pool};
// 4. 스레드 로컬 풀
thread_local ObjectPool<T> pool(100);

FAQ

Q1: Memory Pool?

A: 메모리 미리 할당.

Q2: 장점?

빠른 할당
단편화 방지
캐시 친화적

Q3: 풀 크기?

A: 사용 패턴에 따라 결정.

Q4: 스레드 안전?

A: 뮤텍스 또는 스레드 로컬.

Q5: 소멸자?

A: 명시적 호출 필요.

Q6: 학습 리소스는?

“Game Programming Patterns”
“Effective C++”
cppreference.com

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

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

이 글의 핵심

Memory Pool이란?

기본 구조

실전 예시

예시 1: 고정 크기 풀

예시 2: 스레드 안전 풀

예시 3: RAII 래퍼

예시 4: 가변 크기 풀

장점

자주 발생하는 문제

문제 1: 풀 크기

문제 2: 메모리 누수

문제 3: 스레드 안전

문제 4: 소멸자

활용 패턴

FAQ

Q1: Memory Pool?

Q2: 장점?

Q3: 풀 크기?

Q4: 스레드 안전?

Q5: 소멸자?

Q6: 학습 리소스는?

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

관련 글