2. 类模板

## 示例
```cpp
#include <vector>
#include <cassert>

template<typename T>
class Stack {
private:
    std::vector<T> elems;

public:
    void push(T const& value);
    void pop();
    T const& top() const;
    bool empty() const{
        return elems.empty();
    }
};

template<typename T>
void Stack<T>::push(T const& value) {
    elems.push_back(value);
}

template<typename T>
void Stack<T>::pop() {
    assert(elems.size());
    elems.pop_back();
}

template<typename T>
T const& Stack<T>::top() const {
    assert(!elems.empty());
    return elems.back();
}
```

## 声明
```cpp
template<typename T>
class Stack;
```

## 定义
```cpp
template<typename T>
class Stack {
	...
};
```

这个类的类型是Stack\<T\>,其中T是模板参数。因此，每当在声明中使用此类的类型时，除非模板实参可以推导，否则必须使用Stack\<T\>。

**成员函数的实现**
```cpp
template<typename T>
void Stack<T>::push(T const& value) {
    elems.push_back(value);
}
```

## 引用
```cpp
#include <iostream>
#include <string>
#include "stack1.h"

int main(){
    Stack<int> intStack;				//T是int
    Stack<std::string> strStack;		//T是string

intStack.push(7);
    std::cout << intStack.top() << std::endl;

strStack.push("hello");
    std::cout << strStack.top() << std::endl;

strStack.pop();

}
```
> 只有被调用的模板（成员）函数才会实例化代码。对于类模板，成员函数只有在使用时才会实例化。
> 本例中，默认构造函数、成员函数push()和top()都会为int和string类型实例化出两种类型版本。但成员函数pop()只针对string类型实例化。因为int没有调用pop，如果int也调用了pop，那pop()也会对int类型实例化

## 类模板的特化
接上面的Stack类，来看一段代码
```cpp
#include <vector>
#include <cassert>

template<typename T>
class Stack {
private:
    std::vector<T> elems;

public:
	....
    void printOn(std::ostream & strm) const{
        for(T const & e : elems){
            strm << e << " ";
        }
    }
	....
};

Stack<std::pair<int, int>> ps; //std::pair<> 并没有定义operator<< 操作符
ps.push({4, 5});				//正确
ps.push({8, 9});				//正确
std::cout << ps.top().first << std::endl;			//正确
std::cout << ps.top().second << std::endl;			//正确
std::cout << ps << std::endl;						//错误
```
由于std::pair<>没有operator<< 操作符，导致无法输出。需要对模板做特化。因为我不太熟悉std::pair<>。特化的例子我就用string来示例了。

类模板的特化其实质就是写死`T`的类型。类模板特化时，需要将所有类模板成员函数都做特化。说的带T的成员函数都要做特化。
为了特化类模板，必须用前置template<>的方式声明类，并且声明用来特化类模板的特别定类型。这些类型会用作模板实参，且必须在类名后直接指定。eg:

```CPP
template<>
class Stack<std::string>{
	...
};
```

对于这些特化而言，成员函数的任何定义都必须重定义为“普通”成员函数。eg:
```cpp
void Stack<std::string>::push(std::string const & elem){
	elems.push_back(elem);
}
```
我们看完整示例：

stack1.hpp
```cpp
#pragma once
#include <vector>
#include <cassert>
#include <iostream>
template<typename T>
class Stack {
private:
    std::vector<T> elems;

public:
    void push(T const& value);
    void pop();
    T const& top() const;
    bool empty() const{
        std::cout << "I am Stack<T> member function:empty" << std::endl;
        return elems.empty();
    }
};
```

stack2.hpp
你会发现所有成员函数都是重写了
```cpp
#include "stack1.hpp"   //把模板类引入进来
#include <deque>
#include <string>
#include <cassert>
#include <iostream>
template<>                  //模板声明不一样了
class Stack<std::string>{   //类声明不一样了
private:
    std::deque<std::string> elems;   //容器不一样了
public:
    void push(std::string const&);  //T变成了std::string
    void pop();
    std::string const & top() const; //T变成了std::string
    bool empty() const {
        std::cout << "I am Stack<std::string> member function:empty" << std::endl;
        return elems.empty();
    }
};

void Stack<std::string>::push(std::string const& elem) { 
    std::cout << "I am Stack<std::string> member function:push" << std::endl;
    elems.push_back(elem);
}

void Stack<std::string>::pop() {
    std::cout << "I am Stack<std::string> member function:pop" << std::endl;
    assert(!elems.empty());   //保证不为空
    elems.pop_back();
}

std::string const & Stack<std::string>::top() const {
    std::cout << "I am Stack<std::string> member function:top" << std::endl;
    assert(!elems.empty());   //保证不为空
    return elems.back();
}
```

main.cpp
```cpp
#include <iostream>
#include <string>
#include "stack1.hpp"
#include "stack2.hpp"  //必须把它包含进来，否则还是会去匹配stack1.hpp中的类

int main(){
    Stack<int> intStack;
    Stack<std::string> strStack;

intStack.push(7);
    std::cout << intStack.top() << std::endl;

strStack.push("hello");
    std::cout << strStack.top() << std::endl;

strStack.pop();

}
```

**运行结果:**

![](/media/202408/2024-08-13_141157_5622540.8319388867016931.png)

从结果得出，int走的通用模板，string走的特化模板。

### 偏特化
类模板的部分特化处理
```cpp
#include "stack1.hpp"

template <typename T>
class Stack<T*>{
private:
    std::vector<T*> elems;
public:
    void push(T*);
    T* pop();
    T* top() const;
    bool empty() const{
        return elems.empty();
    }
};

template <typename T>
void Stack<T*>::push(T* elem){
    elems.push_back(elem);
}

template <typename T>
T* Stack<T*>::pop(){
    assert(!elems.empty());
    T* p = elems.back();
    elems.pop_back();
    return p;
}

template <typename T>
T* Stack<T*>::top() const{
    assert(!elems.empty());
    return elems.back();
}
```

通过
```cpp
template <typename T>
class Stack<T*>{
};
```
我们定义了一个类模板，仍用`T`来参数化，但是用指针来特化（Stack\<T\*\>）

### 多参数的偏特化
类模板也可以特化多个模板之间的关系，例如，对于一下类模板:
```cpp
template<typename T1, typename T2>
class MyClass{
	....
}
```
如下偏特化时可以的：

1. 偏特化：两个模板参数具有相同类型
```cpp
//偏特化：两个模板参数具有相同类型
template<typename T>
class MyClass<T, T>{
	....
}
```

2. 偏特化：第2个模板参数是int类型
```cpp
//偏特化：第2个模板参数是int类型
template<typename T>
class MyClass<T, int>{
	....
}
```
3. 偏特化：两个模板参数都是指针类型
```cpp
//偏特化：两个模板参数都是指针类型
template<typename T1*, typename T2*>
class MyClass<T1*, T2*>{
	....
}
```

以下声明，会使用哪个模板：
```cpp
MyClass<int, float> mif;		//使用MyClass<T1 ,T2>
MyClass<float, float> mff;		//使用MyClass<T, T>
MyClass<float, int> mfi;		//使用MyClass<T ,int>
MyClass<int*, float*> mif;		//使用MyClass<T1* ,T2*>
```
如果不止一个偏特化同等程度匹配某个声明，则该声明有歧义
```cpp
MyClass<int, int> m; 		//错误：匹配MyClass<T, T>和MyClass<T, int>
MyClass<T*, T*> m;			//错误：匹配MyClass<T, T>和MyClass<T1*, T2*>
```
为了消除第二个歧义，可以提供另一个相同类型的指针的偏特化：
```cpp
template<typename T>
class MyClass<T*, T*>{
	....
}
```

### 默认类模板参数
```cpp
#pragma once
#include <vector>
#include <cassert>

template <typename T, typename Cont = std::vector<T>>
class Stack {
private:
    Cont elems;
public:
    void push(T const& elem);
    void pop();

T const& top() const;
    bool empty() const { return elems.empty(); }
};

template <typename T, typename Cont>
void Stack<T, Cont>::push(T const& elem) {
    elems.push_back(elem);
}

template <typename T, typename Cont>
void Stack<T, Cont>::pop() {
    assert(!elems.empty());
    elems.pop_back();
}

template <typename T, typename Cont>
T const& Stack<T, Cont>::top() const {
    assert(!elems.empty());
    return elems.back();
}

```

main.cpp
```cpp
#include <iostream>
#include <string>
#include <deque>
#include "stack3.hpp"

int main(){
    //使用默认类模板参数
    Stack<int> intStack;
    //double 类型栈，使用deque来管理元素
    Stack<double, std::deque<double>> dblStack;

intStack.push(7);
    std::cout << intStack.top() << std::endl;
    intStack.pop();

dblStack.push(53.12);
    std::cout << dblStack.top() << std::endl;

dblStack.pop();

}
```