템플릿 특수화

template <> // 템플릿 매개변수 리스트는 비워둡니다.
반환타입 함수이름<특수화할_타입>(매개변수) {
    // 특수화된 타입에 대한 특별한 구현
}

#include <iostream>
#include <string>
#include <typeinfo>
#include <cstring> // C-스타일 문자열 함수를 위해

// 1. 일반 함수 템플릿 정의
template <typename T>
void mySwap(T& a, T& b) {
    std::cout << "일반 템플릿 mySwap() 호출: ";
    T temp = a;
    a = b;
    b = temp;
}

// 2. int 타입에 대한 명시적 특수화
// template <> void mySwap<int>(int& a, int& b) {
//     std::cout << "int 명시적 특수화 mySwap() 호출: ";
//     int temp = a;
//     a = b;
//     b = temp;
// }
// 일반적으로 기본 타입에 대한 특수화는 잘 하지 않습니다.
// 성능상 이득이 없거나 더 나빠질 수 있기 때문입니다.

// 3. const char* 타입에 대한 명시적 특수화
// 문자열 소유권은 이 함수가 갖지 않으므로, 포인터 값만 교환
template <>
void mySwap<const char*>(const char*& a, const char*& b) {
    std::cout << "const char* 명시적 특수화 mySwap() 호출 (포인터 교환): ";
    const char* temp = a;
    a = b;
    b = temp;
}

int main() {
    int i1 = 10, i2 = 20;
    mySwap(i1, i2); // int 일반 템플릿 (또는 int 특수화) 호출
    std::cout << "i1: " << i1 << ", i2: " << i2 << std::endl; // 출력: i1: 20, i2: 10

    double d1 = 1.1, d2 = 2.2;
    mySwap(d1, d2); // double 일반 템플릿 호출
    std::cout << "d1: " << d1 << ", d2: " << d2 << std::endl; // 출력: d1: 2.2, d2: 1.1

    const char* s1 = "Hello";
    const char* s2 = "World";
    mySwap(s1, s2); // const char* 명시적 특수화 호출
    // s1과 s2가 "가리키는 대상"이 바뀜 (문자열 리터럴 메모리를 해제하지 않음)
    std::cout << "s1: " << s1 << ", s2: " << s2 << std::endl; // 출력: s1: World, s2: Hello

    // Note: C-스타일 문자열은 소유권 규칙이 까다롭습니다.
    // "내용 자체"를 교환/복사해야 한다면 const char* 대신 std::string을 사용하는 것이 안전합니다.

    std::string str1 = "Apple";
    std::string str2 = "Banana";
    mySwap(str1, str2); // std::string 일반 템플릿 호출 (std::string 자체는 깊은 복사 지원)
    std::cout << "str1: " << str1 << ", str2: " << str2 << std::endl; // 출력: str1: Banana, str2: Apple

    return 0;
}

template <>
class 클래스이름<특수화할_타입> {
    // 특수화된 타입에 대한 특별한 멤버 변수 및 멤버 함수 구현
};

#include <iostream>
#include <string>
#include <typeinfo>

// 1. 일반 클래스 템플릿 정의
template <typename T>
class MyValue {
private:
    T value;
public:
    MyValue(T val) : value(val) {
        std::cout << "일반 MyValue<" << typeid(T).name() << "> 객체 생성: " << value << std::endl;
    }
    T getValue() const { return value; }
    void setValue(T val) { this->value = val; }
    void display() const {
        std::cout << "일반 MyValue 값: " << value << std::endl;
    }
};

// 2. bool 타입에 대한 명시적 특수화
template <>
class MyValue<bool> {
private:
    // 값의 표현 방식을 바꾸는 예시이며 메모리 절약을 보장하지 않음
    // 여기서는 간단히 int로 저장하여 0/1로 표현
    int internalValue;
public:
    MyValue(bool val) : internalValue(val ? 1 : 0) {
        std::cout << "bool 명시적 특수화 MyValue<bool> 객체 생성: " << (val ? "true" : "false") << std::endl;
    }
    bool getValue() const { return (internalValue == 1); }
    void setValue(bool val) { this->internalValue = (val ? 1 : 0); }
    void display() const {
        std::cout << "bool 특수화 MyValue 값: " << (getValue() ? "True" : "False") << std::endl;
    }
};

// 3. const char* 타입에 대한 명시적 특수화
// 내부 저장은 std::string으로 관리하여 수동 메모리 관리 위험을 제거
template <>
class MyValue<const char*> {
private:
    std::string str;
public:
    explicit MyValue(const char* s) {
        std::cout << "const char* 명시적 특수화 MyValue<const char*> 객체 생성.\n";
        str = (s ? s : "");
    }
    const char* getValue() const { return str.c_str(); }
    void setValue(const char* s) {
        str = (s ? s : "");
    }
    void display() const {
        std::cout << "const char* 특수화 MyValue 값: " << str << std::endl;
    }
};

int main() {
    MyValue<int> intVal(123);           // 일반 템플릿 호출
    intVal.display();

    MyValue<double> doubleVal(45.67);   // 일반 템플릿 호출
    doubleVal.display();

    MyValue<bool> boolVal(true);        // bool 특수화 호출
    boolVal.display();
    boolVal.setValue(false);
    boolVal.display();

    MyValue<const char*> charPtrVal("Hello C++"); // const char* 특수화 호출
    charPtrVal.display();
    charPtrVal.setValue("World");
    charPtrVal.display(); // 출력: const char* 특수화 MyValue 값: World

    return 0;
}

template <typename T> // 하나의 매개변수 T만 남겨둠
class 클래스이름<T, 다른_타입> { // 두 번째 매개변수를 특정 타입으로 고정
    // T 타입에 대한 부분 특수화된 구현
};

template <typename T>
class 클래스이름<T*> { // T 타입 포인터에 대한 부분 특수화
    // T* 타입에 대한 부분 특수화된 구현
};

#include <iostream>
#include <string>
#include <typeinfo>

// 1. 일반 클래스 템플릿 정의 (Pair.h에서 가져옴)
template <typename T1, typename T2>
class Pair {
private:
    T1 first;
    T2 second;
public:
    Pair(T1 f, T2 s) : first(f), second(s) {
        std::cout << "일반 Pair<" << typeid(T1).name() << ", " << typeid(T2).name() << "> 객체 생성.\n";
    }
    void display() const {
        std::cout << "일반 Pair: First=" << first << ", Second=" << second << std::endl;
    }
};

// 2. Pair<T, int> 에 대한 부분 특수화 (두 번째 타입이 int인 경우)
template <typename T>
class Pair<T, int> { // 두 번째 템플릿 매개변수를 int로 고정
private:
    T first;
    int second; // int 타입
public:
    Pair(T f, int s) : first(f), second(s) {
        std::cout << "부분 특수화 Pair<" << typeid(T).name() << ", int> 객체 생성.\n";
    }
    void display() const {
        std::cout << "Pair<T, int>: First=" << first << ", Second=" << second << " (int 특수화)\n";
    }
};

// 3. Pair<T, T*> 에 대한 부분 특수화 (두 번째 타입이 첫 번째 타입의 포인터인 경우)
template <typename T>
class Pair<T, T*> { // 두 번째 템플릿 매개변수를 T* (T의 포인터)로 고정
private:
    T value;
    T* ptr;
public:
    Pair(T v, T* p) : value(v), ptr(p) {
        std::cout << "부분 특수화 Pair<" << typeid(T).name() << ", " << typeid(T*).name() << "> (포인터) 객체 생성.\n";
    }
    void display() const {
        std::cout << "Pair<T, T*>: Value=" << value << ", Ptr=" << (ptr ? *ptr : T{}) << " (포인터 특수화)\n";
    }
};

int main() {
    Pair<double, char> p1(3.14, 'A');  // 일반 Pair 템플릿 사용
    p1.display(); // 출력: 일반 Pair: First=3.14, Second=A

    Pair<std::string, int> p2("Test", 123); // Pair<T, int> 부분 특수화 사용
    p2.display(); // 출력: Pair<T, int>: First=Test, Second=123 (int 특수화)

    int val = 100;
    Pair<int, int*> p3(50, &val); // Pair<T, T*> 부분 특수화 사용
    p3.display(); // 출력: Pair<T, T*>: Value=50, Ptr=100 (포인터 특수화)

    return 0;
}