第二节 · 容器类型的传递 · 转发模板

类模板让我们能够定义与类型无关的类，比如标准库中的 vector、map 都是类模板。

---

基本类模板

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

int main()
{
    Stack<int> intStack;
    intStack.push(1);
    intStack.push(2);
    cout << intStack.pop() << endl;  // 2
    
    Stack<string> stringStack;
    stringStack.push("hello");
    stringStack.push("world");
    cout << stringStack.pop() << endl;  // world
    
    return 0;
}

---

多个模板参数

template<typename K, typename V>
class Pair
{
public:
    K key;
    V value;
    
    Pair(const K& k, const V& v) : key(k), value(v) {}
    
    void print() const
    {
        cout << key << ": " << value << endl;
    }
};

int main()
{
    Pair<string, int> p("age", 25);
    p.print();  // age: 25
    
    Pair<int, string> p2(1, "first");
    p2.print();  // 1: first
    
    return 0;
}

---

默认模板参数

template<typename T = int, int Size = 10>
class Array
{
private:
    T data[Size];
    
public:
    int size() const { return Size; }
    T& operator[](int i) { return data[i]; }
    const T& operator[](int i) const { return data[i]; }
};

int main()
{
    Array<> arr1;           // Array<int, 10>
    Array<double> arr2;     // Array<double, 10>
    Array<char, 5> arr3;    // Array<char, 5>
    
    cout << arr1.size() << endl;  // 10
    cout << arr3.size() << endl;  // 5
    
    return 0;
}

---

成员函数模板

template<typename T>
class Container
{
    T value;
    
public:
    Container(const T& v) : value(v) {}
    
    // 成员函数模板
    template<typename U>
    void assign(const Container<U>& other)
    {
        value = static_cast<T>(other.getValue());
    }
    
    T getValue() const { return value; }
};

int main()
{
    Container<double> cd(3.14);
    Container<int> ci(0);
    
    ci.assign(cd);  // double -> int
    cout << ci.getValue() << endl;  // 3
    
    return 0;
}

---

类模板特化

// 主模板
template<typename T>
class Storage
{
    T value;
public:
    Storage(const T& v) : value(v) {}
    void print() { cout << "Generic: " << value << endl; }
};

// 完全特化：针对 bool
template<>
class Storage<bool>
{
    bool value;
public:
    Storage(bool v) : value(v) {}
    void print()
    {
        cout << "Bool: " << (value ? "true" : "false") << endl;
    }
};

// 部分特化：针对指针类型
template<typename T>
class Storage<T*>
{
    T* ptr;
public:
    Storage(T* p) : ptr(p) {}
    void print()
    {
        if (ptr)
            cout << "Pointer to: " << *ptr << endl;
        else
            cout << "Null pointer" << endl;
    }
};

int main()
{
    Storage<int> s1(42);
    s1.print();  // Generic: 42
    
    Storage<bool> s2(true);
    s2.print();  // Bool: true
    
    int x = 100;
    Storage<int*> s3(&x);
    s3.print();  // Pointer to: 100
    
    return 0;
}

---

类型萃取

// 判断是否为指针
template<typename T>
struct is_pointer
{
    static const bool value = false;
};

template<typename T>
struct is_pointer<T*>
{
    static const bool value = true;
};

// 使用
template<typename T>
void process(T x)
{
    if constexpr (is_pointer<T>::value)
    {
        cout << "Processing pointer, value: " << *x << endl;
    }
    else
    {
        cout << "Processing value: " << x << endl;
    }
}

int main()
{
    int n = 42;
    process(n);   // Processing value: 42
    process(&n);  // Processing pointer, value: 42
    
    return 0;
}

---

CRTP（奇异递归模板模式）

// 基类模板以派生类为模板参数
template<typename Derived>
class Comparable
{
public:
    bool operator!=(const Derived& other) const
    {
        return !(*static_cast<const Derived*>(this) == other);
    }
    
    bool operator>(const Derived& other) const
    {
        return other < *static_cast<const Derived*>(this);
    }
    
    bool operator<=(const Derived& other) const
    {
        return !(static_cast<const Derived*>(this)->operator>(other));
    }
    
    bool operator>=(const Derived& other) const
    {
        return !(*static_cast<const Derived*>(this) < other);
    }
};

class MyInt : public Comparable<MyInt>
{
    int value;
public:
    MyInt(int v) : value(v) {}
    
    bool operator==(const MyInt& other) const { return value == other.value; }
    bool operator<(const MyInt& other) const { return value < other.value; }
};

int main()
{
    MyInt a(5), b(10);
    
    cout << (a < b) << endl;   // 1
    cout << (a > b) << endl;   // 0
    cout << (a != b) << endl;  // 1
    
    return 0;
}

---

类模板的友元

template<typename T>
class Box
{
    T value;
    
public:
    Box(const T& v) : value(v) {}
    
    // 友元函数模板
    template<typename U>
    friend void swap(Box<U>& a, Box<U>& b);
    
    // 特定实例化的友元
    friend class BoxManager;
};

template<typename T>
void swap(Box<T>& a, Box<T>& b)
{
    std::swap(a.value, b.value);
}

---

模板别名

// using 创建模板别名
template<typename T>
using Vec = vector<T>;

template<typename K, typename V>
using Dict = map<K, V>;

// 固定部分参数
template<typename T>
using StringMap = map<string, T>;

int main()
{
    Vec<int> v = {1, 2, 3};
    Dict<string, int> d = {{"one", 1}, {"two", 2}};
    StringMap<double> sm = {{"pi", 3.14}};
    
    return 0;
}

---

习题

• 实现一个通用的 LinkedList 类模板。

• 为特定类型特化一个类模板以提供优化实现。

• 解释 CRTP 的工作原理和应用场景。