C++ 템플릿 특수화 완벽 가이드 | 완전·부분 특수화, 문제 시나리오, 프로덕션 패턴
이 글의 핵심
C++ 템플릿 특수화 완벽 가이드에 대한 실전 가이드입니다. 완전·부분 특수화, 문제 시나리오, 프로덕션 패턴 등을 예제와 함께 상세히 설명합니다.
들어가며: 모든 타입에 같은 로직을 쓸 수 없을 때
”bool은 0/1이 아니라 true/false로 출력하고 싶어요”
템플릿으로 print<T>를 만들어 모든 타입을 처리하고 있었습니다. 그런데 bool을 출력할 때 1과 0이 나와 사용자에게 혼란을 줬습니다. 포인터를 출력할 때는 주소 대신 가리키는 값을 보여주고 싶었고, std::vector는 [1, 2, 3] 형태로 출력하고 싶었습니다.
문제의 코드:
template <typename T>
void print(const T& value) {
std::cout << value << "\n";
}
int main() {
print(42); // 42 ✓
print(true); // 1 ✗ (true로 나오길 원함)
int x = 10;
print(&x); // 0x7fff... ✗ (10이 나오길 원함)
}위 코드 설명: 일반 템플릿은 모든 타입에 동일한 operator<<를 적용합니다. bool은 내부적으로 정수로 저장되어 0/1로 출력되고, 포인터는 주소가 출력됩니다. 특정 타입만 다르게 동작시키려면 템플릿 특수화가 필요합니다.
추가 문제 시나리오
시나리오 1: 직렬화 라이브러리
JSON으로 직렬화할 때 std::string은 따옴표로 감싸야 하고, bool은 true/false 문자열이어야 하며, std::optional은 null 또는 값으로 처리해야 합니다. 타입별로 완전히 다른 직렬화 로직이 필요합니다.
시나리오 2: 설정 파일 파싱
설정값을 int, double, bool, std::string으로 파싱할 때, bool은 “true”/“yes”/“1” 등 다양한 문자열을 처리해야 하고, std::vector<int>는 “1,2,3” 형태의 콤마 구분 파싱이 필요합니다.
시나리오 3: 메모리 풀 최적화
std::vector<bool>은 비트 패킹으로 메모리를 절약하는데, 이는 일반 vector<T>와 완전히 다른 구현이 필요합니다. STL이 vector<bool>을 특수화한 이유입니다.
시나리오 4: 로깅 시스템
포인터 타입은 역참조해서 로그하고, std::chrono::duration은 적절한 단위로 변환해 출력하고, 사용자 정의 타입은 to_string() 메서드를 호출하는 등 타입별 분기가 필요합니다.
템플릿 특수화로 해결:
template <typename T>
void print(const T& value) {
std::cout << "Generic: " << value << "\n";
}
template <>
void print<bool>(const bool& value) {
std::cout << "Bool: " << (value ? "true" : "false") << "\n";
}
template <typename T>
void print(T* ptr) {
if (ptr) std::cout << "Pointer: " << *ptr << "\n";
else std::cout << "Pointer: null\n";
}
int main() {
print(42); // Generic: 42
print(true); // Bool: true
int x = 10;
print(&x); // Pointer: 10
}위 코드 설명: template <> void print<bool>은 bool에 대한 완전 특수화입니다. print(T* ptr)는 포인터 타입에 대한 오버로드로, 특수화와 유사한 효과를 냅니다. 호출 시 컴파일러가 가장 구체적인 버전을 선택합니다.
이 글을 읽으면:
- 완전 특수화와 부분 특수화의 차이를 이해할 수 있습니다.
- 함수·클래스 템플릿 특수화를 실전에서 활용할 수 있습니다.
- SFINAE,
if constexpr로 타입별 분기를 구현할 수 있습니다. - 자주 겪는 에러와 성능 최적화 방법을 알 수 있습니다.
- 프로덕션에서 쓰는 패턴을 적용할 수 있습니다.
이전 글: C++ 템플릿 입문 (#9-1)에서 함수 템플릿 기초를 다뤘습니다.
목차
- 템플릿 특수화 개요
- 완전 특수화 (Full Specialization)
- 부분 특수화 (Partial Specialization)
- 문제 시나리오별 해결 패턴
- 완전한 특수화 예제
- 자주 발생하는 에러와 해결법
- 성능 최적화 팁
- 프로덕션 패턴
- 구현 체크리스트
1. 템플릿 특수화 개요
특수화란?
템플릿 특수화는 “일반 템플릿”이 적용되는 타입 중 특정 타입(또는 패턴)에 대해 별도 구현을 제공하는 기능입니다. 컴파일러는 호출 시 가장 구체적인 버전을 선택합니다.
flowchart TB
subgraph call["호출"]
C1["print(42)"]
C2["print(true)"]
C3["print(ptr)"]
end
subgraph select["선택"]
S1["일반 템플릿 print T"]
S2["완전 특수화 print bool"]
S3["오버로드 print T*"]
end
C1 --> S1
C2 --> S2
C3 --> S3
위 다이어그램 설명: print(42)는 일반 템플릿, print(true)는 bool 특수화, print(ptr)는 포인터 오버로드가 선택됩니다. 더 구체적인 버전이 우선합니다.
특수화 종류
| 종류 | 함수 템플릿 | 클래스 템플릿 | 예시 |
|---|---|---|---|
| 완전 특수화 | ✅ | ✅ | print<bool>, Vector<bool> |
| 부분 특수화 | ❌ (오버로드로 대체) | ✅ | Vector<T*>, Pair<T,T> |
위 표 설명: 함수 템플릿은 부분 특수화를 직접 지원하지 않습니다. 대신 더 구체적인 오버로드를 추가해 같은 효과를 냅니다. 클래스 템플릿은 완전·부분 특수화 모두 지원합니다.
선택 순서
컴파일러가 오버로드/특수화를 선택할 때 가장 구체적인 것이 우선합니다.
// 1. 가장 일반적
template <typename T>
void f(T);
// 2. 포인터 (더 구체적)
template <typename T>
void f(T*);
// 3. 완전 특수화 (가장 구체적)
template <>
void f<int*>(int*);
// f(&x) where x is int → f<int*>(int*) 선택위 코드 설명: f(&x)에서 x가 int면 int*가 전달됩니다. f<int*>(int*) 완전 특수화가 f(T*)보다, f(T*)가 f(T)보다 구체적이므로 최종적으로 f<int*>가 선택됩니다.
2. 완전 특수화 (Full Specialization)
함수 템플릿 완전 특수화
문법: template <> 다음에 구체적인 타입을 지정합니다.
// 일반 템플릿
template <typename T>
T add(T a, T b) {
return a + b;
}
// int에 대한 완전 특수화
template <>
int add<int>(int a, int b) {
return a + b; // 동일해 보이지만, 인라인 최적화 등 다를 수 있음
}
// std::string에 대한 완전 특수화 (다른 로직)
template <>
std::string add<std::string>(std::string a, std::string b) {
return a + b; // 문자열 연결
}
int main() {
std::cout << add(3, 5) << "\n"; // 8 (특수화 또는 일반)
std::cout << add(std::string("a"), std::string("b")) << "\n"; // "ab"
}위 코드 설명: template <> 반환타입 함수명<구체타입>(매개변수) 형태로 완전 특수화를 정의합니다. add<int>는 일반 버전과 동일할 수 있지만, add<std::string>은 문자열 연결처럼 타입에 맞는 로직을 넣을 수 있습니다.
클래스 템플릿 완전 특수화
// 일반 템플릿
template <typename T>
class Wrapper {
T value;
public:
Wrapper(const T& v) : value(v) {}
void print() const { std::cout << value << "\n"; }
};
// bool 완전 특수화: 비트 플래그처럼 다르게 저장
template <>
class Wrapper<bool> {
bool value;
public:
Wrapper(bool v) : value(v) {}
void print() const {
std::cout << (value ? "true" : "false") << "\n";
}
};
int main() {
Wrapper<int> w1(42);
w1.print(); // 42
Wrapper<bool> w2(true);
w2.print(); // true
}위 코드 설명: template <> class Wrapper<bool>은 bool에 대한 완전 특수화입니다. 멤버 구성, 메서드 구현을 완전히 다르게 할 수 있습니다. STL의 std::vector<bool>이 이 방식으로 비트 패킹을 구현합니다.
void* 특수화
void*는 역참조할 수 없어 일반 포인터 템플릿과 다르게 처리해야 합니다.
template <typename T>
void process(T* ptr) {
if (ptr) std::cout << *ptr << "\n";
}
template <>
void process<void>(void* ptr) {
if (ptr) std::cout << "void* at " << ptr << "\n";
}
int main() {
int x = 42;
process(&x); // 42
void* vp = &x;
process<void>(vp); // void* at 0x...
}위 코드 설명: void*는 *ptr로 역참조할 수 없으므로 별도 특수화가 필요합니다. process<void>(vp)처럼 명시적으로 void를 지정해 호출합니다.
3. 부분 특수화 (Partial Specialization)
클래스 템플릿 부분 특수화
부분 특수화는 “모든 타입”이 아니라 “특정 패턴의 타입”에 대해 다른 구현을 제공합니다. 함수 템플릿은 부분 특수화를 지원하지 않으므로, 여기서는 클래스 템플릿만 다룹니다.
포인터 타입 특수화
// 일반 템플릿
template <typename T>
class Container {
T value;
public:
Container(const T& v) : value(v) {}
T get() const { return value; }
void print() const { std::cout << value << "\n"; }
};
// T*에 대한 부분 특수화
template <typename T>
class Container<T*> {
T* ptr;
public:
Container(T* p) : ptr(p) {}
T& get() const { return *ptr; }
void print() const {
if (ptr) std::cout << *ptr << "\n";
else std::cout << "null\n";
}
};
int main() {
int x = 42;
Container<int> c1(x);
c1.print(); // 42
Container<int*> c2(&x);
c2.print(); // 42 (역참조해서 출력)
}위 코드 설명: Container<T*>는 “T가 포인터 타입일 때” 선택됩니다. Container<int>는 일반 버전, Container<int*>는 포인터 특수화가 사용됩니다. 포인터는 역참조해서 값을 다루므로 저장 방식과 인터페이스가 달라집니다.
두 타입이 같을 때
template <typename T, typename U>
class Pair {
public:
static constexpr bool same_type = false;
};
template <typename T>
class Pair<T, T> {
public:
static constexpr bool same_type = true;
};
int main() {
std::cout << Pair<int, double>::same_type << "\n"; // 0
std::cout << Pair<int, int>::same_type << "\n"; // 1
}위 코드 설명: Pair<T, T>는 두 타입 인자가 같을 때만 매칭됩니다. 타입 메타프로그래밍에서 “두 타입이 같은지” 검사할 때 자주 쓰는 패턴입니다.
배열 타입 특수화
template <typename T>
class ArrayInfo {
public:
static constexpr bool is_array = false;
static constexpr size_t extent = 0;
};
template <typename T, size_t N>
class ArrayInfo<T[N]> {
public:
static constexpr bool is_array = true;
static constexpr size_t extent = N;
};
int main() {
std::cout << ArrayInfo<int>::is_array << "\n"; // 0
std::cout << ArrayInfo<int[5]>::is_array << "\n"; // 1
std::cout << ArrayInfo<int[5]>::extent << "\n"; // 5
}위 코드 설명: ArrayInfo<T[N]>은 “T 타입의 N개 배열”에 대해 특수화됩니다. std::extent 같은 타입 트레잇 구현에 쓰이는 패턴입니다.
함수 템플릿: 오버로드로 부분 특수화 대체
함수 템플릿은 부분 특수화가 없으므로, 더 구체적인 오버로드로 같은 효과를 냅니다.
// 일반
template <typename T>
void serialize(const T& value) {
std::cout << "Generic serialize\n";
}
// 포인터 "부분 특수화" 대체
template <typename T>
void serialize(T* ptr) {
if (ptr) serialize(*ptr); // 역참조 후 재귀
else std::cout << "null\n";
}
// const char* 특수화 (문자열)
template <>
void serialize<const char*>(const char* const& str) {
std::cout << "String: " << str << "\n";
}
int main() {
int x = 42;
serialize(x); // Generic serialize
serialize(&x); // 포인터 → Generic serialize (42)
serialize("hi"); // String: hi
}위 코드 설명: serialize(T* ptr)는 “T* 패턴”에 대한 오버로드로, 부분 특수화와 유사한 역할을 합니다. serialize<const char*>는 const char*에 대한 완전 특수화로, C 스타일 문자열을 다룹니다.
4. 문제 시나리오별 해결 패턴
시나리오 1: 타입별 직렬화 포맷
문제: JSON 직렬화 시 int는 42, std::string은 "hello", bool은 true/false로 출력해야 합니다.
#include <string>
#include <sstream>
template <typename T>
std::string toJson(const T& value) {
std::ostringstream oss;
oss << value;
return oss.str();
}
template <>
std::string toJson<bool>(const bool& value) {
return value ? "true" : "false";
}
template <>
std::string toJson<std::string>(const std::string& value) {
return "\"" + value + "\"";
}
int main() {
std::cout << toJson(42) << "\n"; // 42
std::cout << toJson(true) << "\n"; // true
std::cout << toJson(std::string("hi")) << "\n"; // "hi"
}위 코드 설명: 기본 템플릿은 operator<<로 출력하고, bool과 std::string은 JSON 규격에 맞게 특수화했습니다. 새 타입을 지원하려면 해당 타입에 대한 특수화를 추가하면 됩니다.
시나리오 2: 설정 파싱 (bool 예외 처리)
문제: “true”, “yes”, “1”을 bool로, “1,2,3”을 std::vector<int>로 파싱해야 합니다.
#include <string>
#include <sstream>
#include <vector>
template <typename T>
T parse(const std::string& str) {
T result;
std::istringstream iss(str);
iss >> result;
return result;
}
template <>
bool parse<bool>(const std::string& str) {
if (str == "true" || str == "yes" || str == "1") return true;
if (str == "false" || str == "no" || str == "0") return false;
throw std::invalid_argument("Invalid bool: " + str);
}
template <>
std::vector<int> parse<std::vector<int>>(const std::string& str) {
std::vector<int> result;
std::istringstream iss(str);
std::string token;
while (std::getline(iss, token, ',')) {
result.push_back(std::stoi(token));
}
return result;
}
int main() {
auto b = parse<bool>("yes"); // true
auto v = parse<std::vector<int>>("1,2,3"); // {1,2,3}
}위 코드 설명: parse<bool>은 다양한 문자열을 bool로 변환하고, parse<std::vector<int>>는 콤마 구분 파싱을 구현합니다. std::istringstream의 기본 operator>>로는 이런 형식을 처리할 수 없어 특수화가 필요합니다.
시나리오 3: 포인터 vs 값 구분
문제: 포인터일 때는 null 체크 후 역참조, 값일 때는 그대로 처리해야 합니다.
template <typename T>
void log(const T& value) {
std::cout << "[LOG] " << value << "\n";
}
template <typename T>
void log(T* ptr) {
if (ptr) {
std::cout << "[LOG] *ptr = " << *ptr << "\n";
} else {
std::cout << "[LOG] null pointer\n";
}
}
int main() {
int x = 42;
log(x); // [LOG] 42
log(&x); // [LOG] *ptr = 42
log<int>(nullptr); // [LOG] null pointer
}위 코드 설명: log(const T&)와 log(T*)는 서로 다른 오버로드입니다. 포인터를 넘기면 log(T*)가 선택되고, null 체크 후 역참조해 로그합니다.
시나리오 4: 컨테이너 타입 감지
문제: std::vector, std::list 등 컨테이너인지에 따라 다른 알고리즘을 적용하고 싶습니다.
#include <vector>
#include <list>
#include <type_traits>
template <typename T, typename = void>
struct is_container : std::false_type {};
template <typename T>
struct is_container<T, std::void_t<
typename T::value_type,
typename T::iterator,
decltype(std::declval<T>().begin()),
decltype(std::declval<T>().end())
>> : std::true_type {};
template <typename T>
void process(const T& value) {
if constexpr (is_container<T>::value) {
std::cout << "Container with " << value.size() << " elements\n";
} else {
std::cout << "Single value: " << value << "\n";
}
}
int main() {
process(42); // Single value: 42
process(std::vector<int>{1,2,3}); // Container with 3 elements
}위 코드 설명: is_container는 SFINAE로 value_type, begin(), end() 등이 있는 타입을 컨테이너로 판단합니다. if constexpr로 컴파일 시점에 분기해 타입별로 다른 코드를 생성합니다.
5. 완전한 특수화 예제
예제 1: 타입 안전한 TypeId
#include <typeinfo>
#include <string>
template <typename T>
struct TypeId {
static std::string name() {
return typeid(T).name();
}
};
// 자주 쓰는 타입 특수화 (가독성)
template <>
struct TypeId<int> {
static std::string name() { return "int"; }
};
template <>
struct TypeId<double> {
static std::string name() { return "double"; }
};
template <>
struct TypeId<std::string> {
static std::string name() { return "std::string"; }
};
int main() {
std::cout << TypeId<int>::name() << "\n"; // int
std::cout << TypeId<std::vector<int>>::name() << "\n"; // 컴파일러 의존
}위 코드 설명: typeid(T).name()은 구현체마다 다르고 읽기 어렵습니다. 자주 쓰는 타입에 대해 특수화로 사람이 읽기 쉬운 이름을 반환하도록 했습니다.
예제 2: 제로 오버헤드 추상화 (크기 특수화)
template <typename T, size_t N>
struct Buffer {
T data[N];
static constexpr size_t size = N;
};
// N=0인 경우 특수화 (빈 버퍼)
template <typename T>
struct Buffer<T, 0> {
static constexpr size_t size = 0;
// data 멤버 없음 → 메모리 0
};
int main() {
Buffer<int, 10> b1;
Buffer<int, 0> b0; // sizeof(b0) 최소화
std::cout << b1.size << " " << b0.size << "\n"; // 10 0
}위 코드 설명: Buffer<T, 0>은 data 멤버 없이 size만 제공합니다. 빈 버퍼에 메모리를 쓰지 않는 제로 오버헤드 패턴입니다.
예제 3: 스마트 포인터 타입별 삭터
template <typename T>
struct Deleter {
void operator()(T* ptr) const {
delete ptr;
}
};
template <typename T>
struct Deleter<T[]> {
void operator()(T* ptr) const {
delete[] ptr;
}
};
template <typename T, typename D = Deleter<T>>
class UniquePtr {
T* ptr;
D deleter;
public:
explicit UniquePtr(T* p) : ptr(p) {}
~UniquePtr() { if (ptr) deleter(ptr); }
T* get() const { return ptr; }
};
int main() {
UniquePtr<int> p1(new int(42));
UniquePtr<int[]> p2(new int[5]);
// p1 소멸 시 delete, p2 소멸 시 delete[]
}위 코드 설명: Deleter<T[]>는 배열 타입에 대한 부분 특수화로 delete[]를 사용합니다. std::unique_ptr의 기본 삭터와 같은 패턴입니다.
예제 4: JSON 직렬화 전체 예제
#include <iostream>
#include <string>
#include <vector>
#include <sstream>
template <typename T>
struct JsonSerializer {
static std::string serialize(const T& value) {
std::ostringstream oss;
oss << value;
return oss.str();
}
};
template <>
struct JsonSerializer<bool> {
static std::string serialize(bool value) {
return value ? "true" : "false";
}
};
template <>
struct JsonSerializer<std::string> {
static std::string serialize(const std::string& value) {
return "\"" + value + "\"";
}
};
template <typename T>
struct JsonSerializer<std::vector<T>> {
static std::string serialize(const std::vector<T>& vec) {
std::string result = "[";
for (size_t i = 0; i < vec.size(); ++i) {
if (i > 0) result += ",";
result += JsonSerializer<T>::serialize(vec[i]);
}
result += "]";
return result;
}
};
int main() {
std::cout << JsonSerializer<int>::serialize(42) << "\n";
std::cout << JsonSerializer<bool>::serialize(true) << "\n";
std::cout << JsonSerializer<std::string>::serialize("hi") << "\n";
std::vector<int> v = {1, 2, 3};
std::cout << JsonSerializer<std::vector<int>>::serialize(v) << "\n";
}실행 결과:
42
true
"hi"
[1,2,3]위 코드 설명: JsonSerializer를 타입별로 특수화했습니다. std::vector<T>는 JsonSerializer<T>를 재귀적으로 사용해 중첩 벡터도 처리할 수 있습니다.
6. 자주 발생하는 에러와 해결법
에러 1: 특수화 선언과 정의 불일치
증상: error: template-id does not match any template declaration
// 선언
template <typename T>
void foo(T);
// ❌ 잘못된 특수화: 매개변수 타입 불일치
template <>
void foo<int>(int x, int y); // 매개변수 개수 다름!해결: 특수화의 시그니처는 원본 템플릿과 동일해야 합니다.
template <>
void foo<int>(int x); // ✅ 매개변수 일치위 코드 설명: 특수화는 “같은 템플릿의 다른 구현”이므로 함수 시그니처(매개변수 타입·개수, 반환 타입)가 원본과 일치해야 합니다.
에러 2: 부분 특수화에서 원본보다 일반적인 경우
증상: error: partial specialization does not specialize any template parameter
template <typename T, typename U>
class Pair { };
// ❌ T, U를 특수화하지 않고 다른 것만 추가
template <typename X>
class Pair<X, X> { }; // ✅ 이건 OK: T=X, U=X
// ❌ 잘못된 예: 원본보다 더 일반적
template <typename T>
class Pair<T, int> { }; // ✅ 이건 OK: U를 int로 고정해결: 부분 특수화는 원본보다 더 구체적이어야 합니다. 모든 템플릿 인자를 그대로 두면 안 됩니다.
에러 3: 함수 템플릿 부분 특수화 시도
증상: C++에서 함수 템플릿 부분 특수화는 문법상 허용되지 않습니다.
template <typename T>
void bar(T value) { }
// ❌ 에러: 함수 템플릿 부분 특수화 불가
template <typename T>
void bar<T*>(T* ptr) { }해결: 오버로드로 대체합니다.
template <typename T>
void bar(T* ptr) { // ✅ 오버로드
// ...
}위 코드 설명: 함수 템플릿은 부분 특수화를 지원하지 않습니다. bar(T*)처럼 더 구체적인 오버로드를 추가해 같은 효과를 냅니다.
에러 4: 특수화 순서/ODR 위반
증상: 같은 특수화를 여러 번 정의하면 ODR(One Definition Rule) 위반입니다.
// a.cpp
template <>
void foo<int>(int x) { /* 구현 A */ }
// b.cpp
template <>
void foo<int>(int x) { /* 구현 B */ } // ❌ 중복 정의!해결: 특수화는 한 번만 정의합니다. 헤더에 인라인으로 두거나, 한 .cpp에만 둡니다.
// foo.h
template <typename T>
void foo(T x);
template <>
inline void foo<int>(int x) { /* 구현 */ } // ✅ 헤더에 인라인에러 5: 재귀 특수화 종료 조건 누락
증상: 무한 재귀 또는 컴파일 에러.
template <typename T>
struct Foo {
static constexpr int value = Foo<T*>::value + 1; // T* → T** → ...
};
// ❌ void* 종료 조건 없음 → 무한 재귀해결: template <> struct Foo<void*> { static constexpr int value = 0; };처럼 종료 조건 특수화를 반드시 추가합니다.
7. 성능 최적화 팁
팁 1: 인스턴스화 비용 최소화
특수화를 많이 두면 컴파일 시간과 바이너리 크기가 늘어납니다. 실제로 쓰는 타입만 특수화하세요.
// ❌ 사용하지 않는 타입까지 특수화
template <> void process<MyRareType>(...) { }
// ✅ 자주 쓰는 타입만 특수화
template <> void process<int>(...) { }
template <> void process<std::string>(...) { }팁 2: extern template로 중복 인스턴스화 방지
여러 .cpp에서 같은 템플릿 인스턴스를 쓰면 각각 컴파일해 링크 시 합칩니다. extern template으로 한 번만 인스턴스화할 수 있습니다.
// my_template.h
template <typename T>
void heavyFunc(T value) { /* 무거운 구현 */ }
// my_template.cpp
#include "my_template.h"
template void heavyFunc<int>(int); // 명시적 인스턴스화
template void heavyFunc<double>(double);
// main.cpp
#include "my_template.h"
extern template void heavyFunc<int>(int); // 이 TU에서는 인스턴스화 안 함
extern template void heavyFunc<double>(double);
int main() {
heavyFunc(42); // my_template.cpp의 인스턴스 사용
heavyFunc(3.14);
}위 코드 설명: extern template은 “이 타입으로의 인스턴스화는 다른 번역 단위에 있다”고 알립니다. 컴파일 시간을 줄일 수 있습니다.
팁 3: if constexpr로 불필요한 코드 제거
C++17 if constexpr로 컴파일 시점에 분기하면, 선택되지 않은 브랜치의 코드는 생성되지 않습니다.
template <typename T>
void process(const T& value) {
if constexpr (std::is_pointer_v<T>) {
std::cout << *value << "\n"; // 포인터일 때만
} else {
std::cout << value << "\n";
}
}위 코드 설명: T가 포인터가 아니면 *value 코드 자체가 컴파일되지 않아, 역참조 관련 에러를 피할 수 있습니다.
팁 4: 특수화 vs 런타임 분기
| 방식 | 컴파일 시간 | 런타임 비용 | 바이너리 크기 |
|---|---|---|---|
| 특수화 | 증가 | 없음 | 증가 |
| if/switch | 동일 | 분기 비용 | 동일 |
타입이 컴파일 시점에 알려지면 특수화가 유리합니다. 런타임에 타입이 정해지면 std::visit, 가상 함수 등이 적합합니다.
8. 프로덕션 패턴
패턴 1: 타입 트레잇 + 특수화
template <typename T, typename = void>
struct has_to_string : std::false_type {};
template <typename T>
struct has_to_string<T, std::void_t<decltype(std::declval<T>().to_string())>>
: std::true_type {};
template <typename T>
std::string toString(const T& value) {
if constexpr (has_to_string<T>::value) {
return value.to_string();
} else {
return std::to_string(value); // 산술 타입 등
}
}위 코드 설명: has_to_string으로 to_string() 메서드 존재 여부를 검사하고, toString에서 if constexpr로 분기합니다. 사용자 정의 타입에 to_string()이 있으면 호출하고, 없으면 std::to_string을 시도합니다.
패턴 2: 태그 디스패치
struct vector_tag {};
struct list_tag {};
template <typename T>
struct container_tag {
using type = vector_tag;
};
template <typename T, typename A>
struct container_tag<std::vector<T, A>> {
using type = vector_tag;
};
template <typename T, typename A>
struct container_tag<std::list<T, A>> {
using type = list_tag;
};
template <typename C>
void algorithm_impl(const C& c, vector_tag) {
std::cout << "vector-optimized\n";
}
template <typename C>
void algorithm_impl(const C& c, list_tag) {
std::cout << "list-optimized\n";
}
template <typename C>
void algorithm(const C& c) {
algorithm_impl(c, typename container_tag<C>::type{});
}위 코드 설명: container_tag로 컨테이너 종류를 분류하고, algorithm_impl을 태그별로 오버로드합니다. STL 알고리즘에서 자주 쓰는 패턴입니다.
패턴 3: CRTP + 특수화
CRTP와 특수화를 조합하면 특정 파생 클래스에 대해 기본 동작을 바꿀 수 있습니다. template <> struct Base<Impl1>로 Impl1만 다른 interface()를 제공합니다.
패턴 4: 설정 파싱 프로덕션 예제
#include <string>
#include <sstream>
#include <stdexcept>
#include <map>
template <typename T>
T getConfig(const std::map<std::string, std::string>& config,
const std::string& key) {
auto it = config.find(key);
if (it == config.end()) {
throw std::runtime_error("Missing config: " + key);
}
T result;
std::istringstream iss(it->second);
if (!(iss >> result)) {
throw std::runtime_error("Invalid config " + key + " = " + it->second);
}
return result;
}
template <>
bool getConfig<bool>(const std::map<std::string, std::string>& config,
const std::string& key) {
auto it = config.find(key);
if (it == config.end()) {
throw std::runtime_error("Missing config: " + key);
}
const auto& v = it->second;
if (v == "true" || v == "1" || v == "yes") return true;
if (v == "false" || v == "0" || v == "no") return false;
throw std::runtime_error("Invalid bool config " + key + " = " + v);
}
int main() {
std::map<std::string, std::string> cfg = {
{"port", "8080"},
{"debug", "true"}
};
int port = getConfig<int>(cfg, "port");
bool debug = getConfig<bool>(cfg, "debug");
}위 코드 설명: 설정 맵에서 값을 읽을 때 타입별로 파싱합니다. bool은 “true”/“yes”/“1” 등을 처리하고, 나머지는 istringstream으로 파싱합니다. 에러 처리까지 포함한 프로덕션 스타일 예제입니다.
9. 구현 체크리스트
템플릿 특수화를 도입할 때 확인할 항목입니다.
- 필요성: 정말 특수화가 필요한가? (일부 타입만 다르게 동작하는가?)
- 완전 vs 부분: 한 타입만 예외인가(완전), 패턴 단위인가(부분)?
- 함수 템플릿: 부분 특수화 대신 오버로드를 사용했는가?
- 시그니처 일치: 특수화의 시그니처가 원본과 동일한가?
- 재귀 종료: 재귀적 특수화에 종료 조건이 있는가?
- ODR: 같은 특수화를 여러 번 정의하지 않았는가?
- 성능: 불필요한 인스턴스화를 줄였는가? (
extern template등) - 에러 메시지:
static_assert로 요구사항을 명시했는가?
일반적인 실수와 주의점
실수 1: 특수화를 .cpp에 두고 헤더에서 선언만 하기
템플릿 특수화도 사용하는 모든 번역 단위에서 정의가 보여야 합니다. 헤더에 정의를 두거나, 한 .cpp에 두고 해당 .cpp를 링크하세요.
실수 2: 부분 특수화가 원본보다 일반적인 경우
부분 특수화는 항상 원본보다 구체적이어야 합니다. template <typename T> class C<T>처럼 모든 인자를 그대로 두면 안 됩니다.
실수 3: 함수 템플릿 부분 특수화
함수 템플릿은 부분 특수화가 없습니다. template <typename T> void f(T*)처럼 오버로드를 추가하세요.
실수 4: 특수화 순서
특수화는 항상 일반 템플릿 선언/정의 다음에 두세요.
같이 보면 좋은 글 (내부 링크)
이 주제와 연결되는 다른 글입니다.
- C++ 템플릿 입문 | template
와 템플릿 컴파일 에러 해결법 - C++ 클래스 템플릿 | 제네릭 컨테이너와 부분 특수화
- C++ 가변 인자 템플릿 | Variadic Templates와 Fold Expression
이 글에서 다루는 키워드 (관련 검색어)
C++ 템플릿 특수화, 완전 특수화, 부분 특수화, template specialization, SFINAE, if constexpr, 타입 트레잇 등으로 검색하시면 이 글이 도움이 됩니다.
정리
| 항목 | 내용 |
|---|---|
| 완전 특수화 | template <> void f<int>(int) |
| 부분 특수화 | 클래스만, template <typename T> class C<T*> |
| 함수 부분 특수화 | 미지원 → 오버로드로 대체 |
| 선택 규칙 | 가장 구체적인 버전 우선 |
| 자주 쓰는 패턴 | 포인터, bool, 배열, 동일 타입 쌍 |
| 에러 방지 | 시그니처 일치, ODR, 재귀 종료 |
| 성능 | extern template, if constexpr |
| 프로덕션 | 타입 트레잇, 태그 디스패치, 설정 파싱 |
참고 자료
- cppreference - Template specialization
- cppreference - Partial template specialization
- cppreference - Type traits
자주 묻는 질문 (FAQ)
Q. 함수 템플릿은 왜 부분 특수화가 없나요?
A. C++ 표준에서 함수 템플릿 부분 특수화를 허용하지 않습니다. 대신 더 구체적인 오버로드를 추가하면 같은 효과를 낼 수 있어, 문법을 복잡하게 만들지 않기 위한 선택으로 보입니다.
Q. 특수화와 오버로드 중 뭘 써야 하나요?
A. 한 타입만 예외면 완전 특수화, “포인터 전체”처럼 패턴이면 함수는 오버로드·클래스는 부분 특수화를 사용합니다. 오버로드는 여러 개 조합이 가능해 함수에서는 더 유연합니다.
Q. std::vector<bool>이 특수화된 이유는?
A. bool은 1비트로 표현 가능한데, 1바이트씩 저장하면 메모리 낭비가 큽니다. vector<bool>은 비트 패킹으로 8개 bool을 1바이트에 저장해 메모리를 절약합니다. 대신 operator[]가 프록시를 반환하는 등 인터페이스가 달라져, “진짜 컨테이너”가 아니라는 비판도 있습니다.
Q. if constexpr vs 특수화, 언제 뭘 쓰나요?
A. if constexpr는 한 함수 안에서 타입별 분기가 필요할 때 간결합니다. 특수화는 구현 전체가 완전히 다를 때, 또는 클래스 템플릿에서 구조 자체가 달라질 때 유리합니다. 둘을 조합해도 됩니다.
한 줄 요약: 특정 타입만 다르게 동작해야 할 때 템플릿 특수화를 사용합니다. 함수는 완전 특수화와 오버로드, 클래스는 완전·부분 특수화를 활용하세요.
다음 글: C++ 실전 가이드 #9-3: 가변 인자 템플릿
실습 추천: 이 글의 toJson, parse, JsonSerializer 예제를 복사해 컴파일한 뒤, 새 타입에 대한 특수화를 추가해 보세요. g++ -std=c++17 -o test test.cpp로 빌드하면 됩니다.
관련 글
- C++ 클래스 템플릿 | 제네릭 컨테이너와 부분 특수화
- C++ 템플릿 입문 | template
와 템플릿 컴파일 에러 해결법 - C++ 가변 인자 템플릿 | Variadic Templates와 Fold Expression
- C++ 예외 처리 | try-catch-throw와 예외 vs 에러 코드, 언제 뭘 쓸지
- C++ 예외 안전성 |