C++ 템플릿 | "제네릭 프로그래밍" 초보자 가이드

템플릿이란?

템플릿 (Template) 은 타입에 독립적인 코드를 작성하는 C++ 제네릭 프로그래밍 기법입니다. 컴파일 타임에 타입별로 코드가 생성됩니다.

왜 필요한가?:

• 코드 재사용: 타입별 중복 제거
• 타입 안전: 컴파일 타임 타입 체크
• 성능: 런타임 오버헤드 없음
• 유연성: 다양한 타입 지원

// ❌ 타입별 중복 코드
int maxInt(int a, int b) { return (a > b) ? a : b; }
double maxDouble(double a, double b) { return (a > b) ? a : b; }
char maxChar(char a, char b) { return (a > b) ? a : b; }

// ✅ 템플릿: 재사용
template <typename T>
T max(T a, T b) {
    return (a > b) ? a : b;
}

max(3, 5);      // int
max(3.5, 2.1);  // double
max('a', 'z');  // char

템플릿 동작 원리:

flowchart LR
    A[템플릿 정의] --> B[컴파일러]
    B -->|int 호출| C[int 버전 생성]
    B -->|double 호출| D[double 버전 생성]
    B -->|string 호출| E[string 버전 생성]
    C --> F[실행 파일]
    D --> F
    E --> F

템플릿 인스턴스화:

// 템플릿 정의
template <typename T>
T max(T a, T b) {
    return (a > b) ? a : b;
}

// 호출
max(3, 5);      // int 버전 생성
max(3.5, 2.1);  // double 버전 생성

// 내부 동작 (개념적)
// int max(int a, int b) { return (a > b) ? a : b; }
// double max(double a, double b) { return (a > b) ? a : b; }

함수 템플릿

template <typename T>
T max(T a, T b) {
    return (a > b) ? a : b;
}

int main() {
    cout << max(3, 5) << endl;        // int
    cout << max(3.5, 2.1) << endl;    // double
    cout << max('a', 'z') << endl;    // char
}

함수 템플릿 특징:

특징	설명
타입 추론	컴파일러가 자동 추론
명시적 지정	max<int>(3, 5)
오버로딩	일반 함수와 함께 사용
인라인	인라인 최적화 가능

// 타입 추론
max(3, 5);  // T = int

// 명시적 지정
max<double>(3, 5);  // T = double

// 오버로딩
template <typename T>
T max(T a, T b) { return (a > b) ? a : b; }

int max(int a, int b) { return (a > b) ? a : b; }  // 일반 함수 우선

클래스 템플릿

template <typename T>
class Box {
private:
    T value;
    
public:
    Box(T v) : value(v) {}
    
    T getValue() { return value; }
    void setValue(T v) { value = v; }
};

int main() {
    Box<int> intBox(10);
    Box<string> strBox("Hello");
    
    cout << intBox.getValue() << endl;
    cout << strBox.getValue() << endl;
}

여러 타입 매개변수

template <typename T, typename U>
class Pair {
public:
    T first;
    U second;
    
    Pair(T f, U s) : first(f), second(s) {}
};

int main() {
    Pair<int, string> p(1, "one");
    cout << p.first << ": " << p.second << endl;
}

실전 예시

예시 1: 제네릭 스택

#include <iostream>
#include <vector>
using namespace std;

template <typename T>
class Stack {
private:
    vector<T> data;
    
public:
    void push(const T& value) {
        data.push_back(value);
    }
    
    void pop() {
        if (!empty()) {
            data.pop_back();
        }
    }
    
    T& top() {
        return data.back();
    }
    
    bool empty() const {
        return data.empty();
    }
    
    size_t size() const {
        return data.size();
    }
};

int main() {
    Stack<int> intStack;
    intStack.push(1);
    intStack.push(2);
    cout << intStack.top() << endl;  // 2
    
    Stack<string> strStack;
    strStack.push("Hello");
    strStack.push("World");
    cout << strStack.top() << endl;  // World
    
    return 0;
}

설명: 어떤 타입이든 저장할 수 있는 제네릭 스택입니다.

예시 2: 제네릭 배열 유틸리티

#include <iostream>
#include <vector>
using namespace std;

template <typename T>
void printArray(const vector<T>& arr, const string& label) {
    cout << label << ": ";
    for (const T& item : arr) {
        cout << item << " ";
    }
    cout << endl;
}

template <typename T>
T findMax(const vector<T>& arr) {
    T maxVal = arr[0];
    for (const T& item : arr) {
        if (item > maxVal) {
            maxVal = item;
        }
    }
    return maxVal;
}

template <typename T>
vector<T> filter(const vector<T>& arr, bool (*pred)(T)) {
    vector<T> result;
    for (const T& item : arr) {
        if (pred(item)) {
            result.push_back(item);
        }
    }
    return result;
}

bool isEven(int x) { return x % 2 == 0; }

int main() {
    vector<int> numbers = {1, 2, 3, 4, 5};
    printArray(numbers, "숫자");
    cout << "최댓값: " << findMax(numbers) << endl;
    
    vector<int> evens = filter(numbers, isEven);
    printArray(evens, "짝수");
    
    vector<string> words = {"apple", "banana", "cherry"};
    printArray(words, "단어");
    
    return 0;
}

설명: 템플릿으로 타입에 독립적인 유틸리티 함수를 만들 수 있습니다.

예시 3: 제네릭 싱글톤

#include <iostream>
#include <memory>
using namespace std;

template <typename T>
class Singleton {
private:
    static unique_ptr<T> instance;
    
protected:
    Singleton() {}
    
public:
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;
    
    static T& getInstance() {
        if (!instance) {
            instance = make_unique<T>();
        }
        return *instance;
    }
};

template <typename T>
unique_ptr<T> Singleton<T>::instance = nullptr;

class Config : public Singleton<Config> {
private:
    int value;
    
public:
    Config() : value(0) {}
    
    void setValue(int v) { value = v; }
    int getValue() { return value; }
};

int main() {
    Config::getInstance().setValue(100);
    cout << Config::getInstance().getValue() << endl;  // 100
    
    return 0;
}

설명: 템플릿으로 재사용 가능한 싱글톤 패턴을 구현합니다.

자주 발생하는 문제

문제 1: 템플릿 정의를 cpp 파일에 분리

증상: 링크 에러 발생

원인: 템플릿은 컴파일 타임에 인스턴스화되므로 헤더에 정의 필요

해결법:

// ❌ 잘못된 방법
// header.h
template <typename T>
T max(T a, T b);

// source.cpp
template <typename T>
T max(T a, T b) {
    return (a > b) ? a : b;
}
// 링크 에러!

// ✅ 올바른 방법 (헤더에 정의)
// header.h
template <typename T>
T max(T a, T b) {
    return (a > b) ? a : b;
}

문제 2: typename vs class

증상: typename과 class 중 무엇을 써야 할지 혼란

원인: 둘 다 가능하지만 의미가 약간 다름

해결법:

// 둘 다 가능
template <typename T>
template <class T>

// 권장: typename 사용 (더 명확)
template <typename T>

// typename이 필수인 경우
template <typename T>
void func() {
    typename T::value_type v;  // T의 중첩 타입
}

문제 3: 템플릿 특수화

증상: 특정 타입에 대해 다른 구현이 필요

원인: 일반 템플릿으로는 모든 타입을 처리 못함

해결법:

// 일반 템플릿
template <typename T>
class Printer {
public:
    void print(T value) {
        cout << value << endl;
    }
};

// bool 특수화
template <>
class Printer<bool> {
public:
    void print(bool value) {
        cout << (value ? "true" : "false") << endl;
    }
};

int main() {
    Printer<int> intPrinter;
    intPrinter.print(10);  // 10
    
    Printer<bool> boolPrinter;
    boolPrinter.print(true);  // true
}

실무 패턴

패턴 1: 타입 안전 래퍼

template <typename T>
class Handle {
    T* ptr_;
    
public:
    explicit Handle(T* ptr) : ptr_(ptr) {}
    
    ~Handle() {
        delete ptr_;
    }
    
    T* get() const { return ptr_; }
    T& operator*() const { return *ptr_; }
    T* operator->() const { return ptr_; }
    
    Handle(const Handle&) = delete;
    Handle& operator=(const Handle&) = delete;
};

// 사용
Handle<int> handle(new int(42));
std::cout << *handle << '\n';

패턴 2: 범용 알고리즘

template <typename T>
void swap(T& a, T& b) {
    T temp = std::move(a);
    a = std::move(b);
    b = std::move(temp);
}

template <typename T>
T clamp(T value, T min, T max) {
    if (value < min) return min;
    if (value > max) return max;
    return value;
}

// 사용
int x = 5, y = 10;
swap(x, y);  // x=10, y=5

int clamped = clamp(15, 0, 10);  // 10

패턴 3: 컨테이너 어댑터

template <typename T, typename Container = std::vector<T>>
class Stack {
    Container data_;
    
public:
    void push(const T& value) {
        data_.push_back(value);
    }
    
    void pop() {
        if (!empty()) {
            data_.pop_back();
        }
    }
    
    T& top() {
        return data_.back();
    }
    
    bool empty() const {
        return data_.empty();
    }
};

// 사용
Stack<int> stack;  // std::vector 기반
Stack<int, std::deque<int>> dequeStack;  // std::deque 기반

FAQ

Q1: 템플릿은 언제 사용하나요?

A: 타입에 독립적인 코드를 작성할 때 사용합니다. STL 컨테이너가 모두 템플릿입니다.

template <typename T>
T max(T a, T b) {
    return (a > b) ? a : b;
}

Q2: 템플릿과 매크로의 차이는?

A:

• 템플릿: 타입 안전, 컴파일 타임 체크
• 매크로: 단순 텍스트 치환, 위험

// ❌ 매크로: 타입 안전하지 않음
#define MAX(a, b) ((a) > (b) ? (a) : (b))

// ✅ 템플릿: 타입 안전
template <typename T>
T max(T a, T b) { return (a > b) ? a : b; }

Q3: 템플릿은 성능에 영향을 주나요?

A: 아니요, 컴파일 타임에 코드가 생성되므로 런타임 오버헤드가 없습니다.

// 템플릿: 컴파일 타임 생성
max(3, 5);  // int max(int, int) 생성

// 런타임 비용 없음

Q4: 가변 인자 템플릿은?

A: C++11부터 지원합니다.

template <typename... Args>
void print(Args... args) {
    (std::cout << ... << args) << '\n';
}

print(1, 2, 3, "hello");

Q5: 템플릿 컴파일 에러가 너무 길어요!

A: C++20 Concepts를 사용하면 에러 메시지가 간결해집니다.

// ❌ 긴 에러 메시지
template <typename T>
T add(T a, T b) { return a + b; }

// ✅ Concepts: 간결한 에러
template <typename T>
requires std::is_arithmetic_v<T>
T add(T a, T b) { return a + b; }

Q6: 템플릿 디버깅은?

A:

• static_assert: 컴파일 타임 체크
• 명시적 인스턴스화: 에러 확인
• Concepts: 제약 조건 명시

template <typename T>
T add(T a, T b) {
    static_assert(std::is_arithmetic_v<T>, "숫자 타입만");
    return a + b;
}

Q7: 템플릿 정의를 cpp 파일에 분리할 수 있나요?

A: 불가능합니다. 템플릿은 헤더에 정의해야 합니다.

// ❌ 링크 에러
// header.h
template <typename T>
T max(T a, T b);

// source.cpp
template <typename T>
T max(T a, T b) { return (a > b) ? a : b; }

// ✅ 헤더에 정의
// header.h
template <typename T>
T max(T a, T b) { return (a > b) ? a : b; }

Q8: 템플릿 학습 리소스는?

A:

• “C++ Templates: The Complete Guide” by David Vandevoorde
• “Effective Modern C++” by Scott Meyers
• cppreference.com - Templates

관련 글: template-specialization, variadic-templates, SFINAE.

한 줄 요약: 템플릿은 타입에 독립적인 코드를 작성하는 C++ 제네릭 프로그래밍 기법입니다.

---

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

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

• C++ 가변 인자 템플릿 | “가변 템플릿” 완벽 가이드
• C++ constexpr if | “컴파일 타임 분기” 가이드
• C++ SFINAE | “Substitution Failure Is Not An Error” 가이드

관련 글

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