템플릿 특수화

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

#include <iostream>
#include <string>
#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() 호출 (내용 교환): ";
    // char 배열을 동적으로 할당하여 내용 복사
    char* temp_a = new char[strlen(a) + 1];
    strcpy(temp_a, a);

    char* temp_b = new char[strlen(b) + 1];
    strcpy(temp_b, b);
    
    // 포인터 교환 (원래 a가 가리키던 곳에 b의 내용, b가 가리키던 곳에 a의 내용)
    delete[] a;
    a = temp_b;

    delete[] b;
    b = temp_a;
}

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-스타일 문자열을 사용하는 mySwap 특수화는 실제로는 메모리 누수 위험이 있고,
    // 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>

// 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:
    // bool은 1비트만 필요하므로, 메모리 효율을 위해 다른 방식으로 저장할 수 있음
    // 여기서는 간단히 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. char* 타입에 대한 명시적 특수화 (C-스타일 문자열)
template <>
class MyValue<const char*> {
private:
    char* str; // 동적 할당하여 깊은 복사
public:
    MyValue(const char* s) {
        std::cout << "const char* 명시적 특수화 MyValue<const char*> 객체 생성.\n";
        if (s) {
            str = new char[strlen(s) + 1];
            strcpy(str, s);
        } else {
            str = nullptr;
        }
    }
    ~MyValue() {
        std::cout << "const char* 명시적 특수화 MyValue<const char*> 소멸.\n";
        delete[] str;
    }
    // 복사 생성자와 복사 대입 연산자 (규칙 3/5)도 정의해야 하지만, 예시를 위해 생략
    
    const char* getValue() const { return str; }
    void setValue(const char* s) {
        delete[] str;
        if (s) {
            str = new char[strlen(s) + 1];
            strcpy(str, s);
        } else {
            str = nullptr;
        }
    }
    void display() const {
        std::cout << "const char* 특수화 MyValue 값: " << (str ? str : "nullptr") << 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>

// 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 : 0) << " (포인터 특수화)\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;
}