C++ 템플릿 템플릿 인자 | template template parameter 가이드

템플릿 템플릿 인자란?

템플릿 템플릿 인자(template template parameter) 는 템플릿이 다른 템플릿을 인자로 받게 하는 문법입니다. vector<int>처럼 이미 구체화된 타입이 아니라, “어떤 컨테이너 템플릿”을 받아서 그 템플릿에 요소 타입만 넘기고 싶을 때 사용합니다. 템플릿 기초와 템플릿 특수화를 먼저 익히면 이해하기 쉽습니다.

기본 예시

#include <vector>
#include <list>
#include <iostream>

template<template<typename> class Container, typename T>
struct Wrapper {
    Container<T> data;
    
    void add(T value) {
        data.push_back(value);
    }
    
    void print() const {
        for (const auto& item : data) {
            std::cout << item << " ";
        }
        std::cout << '\n';
    }
};

template<typename T>
using Vec = std::vector<T>;

int main() {
    Wrapper<Vec, int> w;  // Wrapper 내부는 std::vector<int>
    w.add(1);
    w.add(2);
    w.add(3);
    w.print();  // 1 2 3
    return 0;
}

동작 원리: Container는 “한 개의 타입 인자를 받는 템플릿”이고, Wrapper는 그 템플릿과 요소 타입 T를 받아 Container<T>를 멤버로 가집니다. 이렇게 하면 Wrapper를 vector, list, deque 등 다양한 컨테이너와 함께 사용할 수 있습니다.

CTAD와의 차이: 클래스 템플릿 인자 추론(CTAD)은 “생성자 인자로부터 템플릿 인자 추론”이고, 템플릿 템플릿 인자는 “템플릿 자체를 인자로 받는 것”입니다. 역할이 다릅니다.

C++17: typename으로도 선언

C++17부터는 class 대신 typename을 쓸 수 있어, 템플릿 인자라는 것이 더 분명해집니다.

template<template<typename> typename Container, typename T>
void use(Container<T>& c) { }

표준 컨테이너에 적용할 때 주의

std::vector, std::list 등은 두 번째 기본 템플릿 인자(할당자)를 갖습니다. 템플릿 템플릿 인자로 그대로 넘기려면 인자 개수를 맞춰야 합니다.

// std::vector의 실제 정의
// template<typename T, typename Alloc = std::allocator<T>> class vector;

// ❌ 인자 개수 불일치
// template<template<typename> class Container, typename T>
// struct Adapter {
//     Container<T> data;  // 에러: vector는 2개 인자 필요
// };

// ✅ 해결 1: 인자 개수 맞추기
template<template<typename, typename> class Container, typename T>
struct Adapter {
    Container<T, std::allocator<T>> data;
};

Adapter<std::vector, int> a;  // OK

// ✅ 해결 2: using으로 래핑 (더 간결)
template<typename T>
using Vec = std::vector<T>;

template<template<typename> class Container, typename T>
struct SimpleAdapter {
    Container<T> data;
};

SimpleAdapter<Vec, int> b;  // OK

왜 이런 문제가?: 템플릿 템플릿 인자는 정확한 인자 개수를 요구합니다. std::vector는 2개 인자(타입, 할당자)를 받지만, template<typename>은 1개만 받으므로 불일치가 발생합니다.

실무 패턴:

1. using 별칭: 표준 컨테이너를 한 인자 템플릿으로 래핑
2. 가변 인자: C++17 이후 template<typename...>로 유연하게 받기

// C++17: 가변 인자로 유연하게
template<template<typename...> class Container, typename T>
struct FlexibleAdapter {
    Container<T> data;  // vector, list, set 모두 OK
};

FlexibleAdapter<std::vector, int> v;
FlexibleAdapter<std::list, int> l;
FlexibleAdapter<std::set, int> s;

실전 예시 1: 컨테이너 정책 주입

여러 컨테이너를 같은 인터페이스로 쓰는 유틸을 만들 때, 템플릿 템플릿 인자로 “컨테이너 템플릿”을 받을 수 있습니다.

#include <vector>
#include <list>
#include <iostream>

template<typename T>
using Vec = std::vector<T>;

template<typename T>
using List = std::list<T>;

template<template<typename> class Container, typename T>
class Repository {
    Container<T> items;
public:
    void add(T x) { items.push_back(x); }
    size_t size() const { return items.size(); }
    
    void print() const {
        for (const auto& item : items) {
            std::cout << item << " ";
        }
        std::cout << '\n';
    }
};

int main() {
    // vector 기반
    Repository<Vec, int> repo_vec;
    repo_vec.add(1);
    repo_vec.add(2);
    repo_vec.print();  // 1 2
    
    // list 기반 (list는 push_back 있음)
    Repository<List, int> repo_list;
    repo_list.add(10);
    repo_list.add(20);
    repo_list.print();  // 10 20
    
    return 0;
}

실무 활용: 데이터 저장소의 내부 구현을 유연하게 바꿀 수 있습니다. 성능 테스트 시 vector vs list를 쉽게 비교할 수 있습니다.

실전 예시 2: 스마트 포인터 정책

#include <memory>
#include <iostream>

template<template<typename> class Ptr, typename T>
class ResourceManager {
    Ptr<T> resource;
public:
    ResourceManager(T* raw) : resource(raw) {}
    
    T* get() { return resource.get(); }
    void reset(T* raw = nullptr) { resource.reset(raw); }
};

// unique_ptr 기반 (독점 소유)
ResourceManager<std::unique_ptr, int> mgr1(new int(42));

// shared_ptr 기반 (공유 소유)
ResourceManager<std::shared_ptr, int> mgr2(new int(100));

실무 의미: 소유권 정책을 템플릿 인자로 받아, 같은 코드로 독점/공유 소유를 선택할 수 있습니다.

실전 예시 3: 표준 라이브러리 패턴 - Allocator

#include <memory>
#include <vector>

template<typename T, template<typename> class Allocator = std::allocator>
class CustomVector {
    std::vector<T, Allocator<T>> data_;
public:
    void push_back(const T& value) {
        data_.push_back(value);
    }
    size_t size() const { return data_.size(); }
};

// 기본 allocator 사용
CustomVector<int> v1;

// 커스텀 allocator 사용
template<typename T>
using CustomAlloc = std::allocator<T>;  // 실제로는 커스텀 구현

CustomVector<int, CustomAlloc> v2;

실무 활용: 메모리 풀, 커스텀 할당자를 주입하여 성능을 최적화할 수 있습니다.

관련 개념과 함께 보기

• 가변 인자 템플릿: 인자 개수가 가변일 때 패킹·확장
• 템플릿 인자 추론: 함수 템플릿에서 타입 생략

자주 발생하는 문제

문제 1: 표준 컨테이너 인자 개수 불일치

증상: error: template template argument has different template parameters

// ❌ 에러
template<template<typename> class Container, typename T>
struct Bad {
    Container<T> data;  // vector는 2개 인자 필요
};

// Bad<std::vector, int> b;  // 컴파일 에러

해결:

// ✅ 해결 1: using 래퍼
template<typename T> using Vec = std::vector<T>;
Bad<Vec, int> b1;

// ✅ 해결 2: 인자 개수 맞추기
template<template<typename, typename> class Container, typename T>
struct Good {
    Container<T, std::allocator<T>> data;
};
Good<std::vector, int> b2;

// ✅ 해결 3: 가변 인자 (C++17)
template<template<typename...> class Container, typename T>
struct Flexible {
    Container<T> data;
};
Flexible<std::vector, int> b3;

문제 2: 구체화된 타입 전달

증상: error: template argument must be a class template

// ❌ 구체화된 타입 전달
// Wrapper<std::vector<int>, int> w;  // 에러

// ✅ 템플릿 이름만 전달
Wrapper<Vec, int> w;

핵심: 템플릿 템플릿 인자는 템플릿 자체(예: std::vector)를 받지, 구체화된 타입(예: std::vector<int>)을 받지 않습니다.

문제 3: 기본 인자와 호환성

// std::map은 4개 인자
// template<typename Key, typename T, typename Compare = std::less<Key>, 
//          typename Alloc = std::allocator<std::pair<const Key, T>>> class map;

// using으로 래핑 필요
template<typename K, typename V>
using Map = std::map<K, V>;

template<template<typename, typename> class Container, typename K, typename V>
struct MapWrapper {
    Container<K, V> data;
};

MapWrapper<Map, int, std::string> mw;

---

실무 패턴

패턴 1: 컨테이너 추상화 레이어

// 컨테이너 인터페이스 통일
template<template<typename> class Container, typename T>
class DataStore {
    Container<T> storage_;
public:
    void store(T value) { storage_.push_back(value); }
    T retrieve(size_t index) { return storage_[index]; }
    size_t count() const { return storage_.size(); }
};

// 성능 테스트: vector vs deque
using VecStore = DataStore<Vec, int>;
using DequeStore = DataStore<Deque, int>;

패턴 2: 정책 기반 설계 (Policy-Based Design)

template<typename T, template<typename> class StoragePolicy>
class Cache {
    StoragePolicy<T> storage_;
public:
    void put(const T& item) { storage_.add(item); }
    T get() { return storage_.retrieve(); }
};

// 다양한 저장 정책
template<typename T> class VectorStorage { /* ... */ };
template<typename T> class ListStorage { /* ... */ };
template<typename T> class SetStorage { /* ... */ };

Cache<int, VectorStorage> cache1;  // vector 기반
Cache<int, SetStorage> cache2;     // set 기반 (중복 제거)

---

정리

항목	설명
문법	template<template<typename> class C, typename T> (C++17부터 typename 가능)
용도	컨테이너·할당자 등 “템플릿인 타입”을 유연하게 받을 때
표준 컨테이너	인자 개수·기본 인자 때문에 using 래퍼를 두고 쓰는 경우가 많음
실무	정책 기반 설계, 컨테이너 추상화, 성능 테스트에 활용

---

FAQ

Q1: 템플릿 템플릿 인자는 언제 사용하나요?

A: 컨테이너, 스마트 포인터, 할당자 등 “템플릿 자체”를 정책으로 주입하고 싶을 때 사용합니다.

Q2: std::vector를 직접 넘길 수 없나요?

A: std::vector는 2개 인자를 받으므로, using으로 1개 인자 템플릿으로 래핑하거나, template<typename...>로 가변 인자를 받아야 합니다.

Q3: class vs typename 키워드?

A: C++17 이전에는 class만 가능했고, C++17부터 typename도 사용할 수 있습니다. 의미는 동일합니다.

Q4: 실무에서 자주 사용하나요?

A: 라이브러리 설계, 정책 기반 설계, 제네릭 컨테이너 래퍼에서 사용합니다. 일반 애플리케이션 코드에서는 드물지만, 재사용 가능한 컴포넌트를 만들 때 유용합니다.

Q5: 디버깅 팁은?

A:

• 에러 메시지에서 “template template parameter” 키워드 확인
• 인자 개수 불일치는 using 래퍼로 해결
• static_assert로 컨테이너 요구사항 검증

Q6: 학습 리소스는?

A:

• “C++ Templates: The Complete Guide” by Vandevoorde
• “Modern C++ Design” by Alexandrescu (정책 기반 설계)
• cppreference - Template parameters

관련 글: 템플릿 기초, 템플릿 특수화, 가변 인자 템플릿, CTAD.

한 줄 요약: 템플릿 템플릿 인자로 컨테이너·정책 클래스를 템플릿 단위로 받아 유연한 설계를 만들 수 있고, 표준 컨테이너는 using 래퍼로 감싸 사용하면 됩니다.

---

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

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

• C++ 템플릿 | “제네릭 프로그래밍” 초보자 가이드
• C++ 템플릿 특수화 | template specialization 가이드
• C++ 가변 인자 템플릿 | Variadic Templates와 Fold Expression
• C++ CTAD | “클래스 템플릿 인자 추론” 가이드
• C++ 템플릿 인자 추론 | template argument deduction 가이드

관련 글

• C++ auto 타입 추론 | 복잡한 타입을 컴파일러에 맡기기
• C++ CTAD |
• C++20 Concepts 완벽 가이드 | 템플릿 제약의 새 시대
• C++ constexpr if |
• C++ 컨테이너 어댑터 |