模板(template)初始

模板原理

在编译器编译阶段，编译器需要根据传入的实参类型来推演生成对应类型的函数以供调用，无须手动干预自动完成。

模板格式：

template <typename T1, typename T2>
类名或函数名 name {
    T1 parameter;
    T2 parameter;
};

代码示例:

template<typename T>//typename，和class都用来定义模板关键字，可替换
void swap( T& left, T& right){
//数据交换操作
}

01. 函数模板实例化

用不同类型的参数使用函数模板时，称为函数模板的实例化。

1.1 显式实例化

手动指定生成特定类型的模板函数

template <class T>
T add(T a, T b) {
    return a + b;
}
int main() {  // 直接显式实例化
    add<int>(3, 5);       
    add<double>(2.5, 3.7); 
    add<int>(2, (int)3.7)
    return 0;
}

---

1.2 隐式实例化

编译器在代码中遇到模板使用时自动生成对应的实例，无需手动声明

template <class T>
T add(T a, T b) {
    return a + b;
}
int main() {
    add(3, 5);      
    add(2.5, 3.7); 
    return 0;
}

1.3 函数模板匹配机制

非模板函数可以和同名的函数模板同时存在，且该函数模板还可以被实例化为这个非模板函数

int Add(int left, int right){// 专门处理int
 return left + right;
 }
 //可以同时存在
template<class T>// 通用类型处理
 T Add(T left, T right){
 return left + right;
 }

如果模板函数和非模板函数都存在且相同情况下，优先调用非模板函数，而不是调用模板函数实例化的函数(优先选择更快的方式)

// 与非函数模板类型完全匹配，不需要函数模板实例化，优先使用非模板函数
Add(1, 2);     
// 模板函数可以生成更加匹配的版本，编译器根据实参生成更加匹配的Add函数
Add(1, 2.0);   

---

02. 类模板

定义格式：

template<class T1, class T2, ..., class Tn> 
class 类模板名{
 // 类内成员定义
};  

注：在类外面定义函数，需要void vector<T>::pushback(const T& x)特殊处理才能通过。

//类外,脱离了类
 template<class T>
 void vector<T>::pushback(const T& x){
 }

2.1 类模板的实例化

类模板名字不是真正的类，而实例化的结果才是真正的类

// Vector类名，Vector<int>才是类型
 Vector<int> s1;
 Vector<double> s2;

顺序表入栈实现：

template <class T>
class vector{//seqlist
    public:
    vector()
    :_a(nullptr),_size(0),_capacity(0){}
    vector(int n)//构造函数可重载
    :_a(nullptr),_size(0),_capacity(0){}
    
    ~vector(){
        	delete[] _a;    _a = nullptr;     _size = _capacity = 0;
    }
    void pushback(const T& x){//类里面定义
        	//当容量与当前储存个数相等时，扩容
        if (_size==_capacity){
         	size_t newcapcity = _capacity == 0 ? 2 : 2 * _capacity;
         	T *tmp = new T[newcapcity];
        if (_a){
            memcpy(tmp, _a, sizeof(T) * _size);
            delete[] _a;
        }
       		_a = tmp;
        	_capacity = newcapcity;
        }
        	_a[_size] = x;
        	++_size;
    }
    T& operator[](size_t i){//访问第i个值;且返回一个临时的变量，不使用引用
        assert(i < _size);
        return _a[i];
    }
    size_t size(){
        return _size;
    }
    //增容int *ptr2 = ptr1;可以等价成int *ptr2 =null；ptr2=ptr1;
    private:
        T *_a;
        size_t _size;//有几个数据
        size_t _capacity;
};
int main(){
    vector<int> v;
    v.pushback(1);
    v.pushback(2);
    v.pushback(3);
    v.pushback(4);
    v.pushback(5);
    v.pushback(6);
    for (int i = 0; i < v.size(); i++){
        cout << v[i] << endl;
    }
    for (int i = 0; i < v.size(); i++){
        v[i] *= 2;
    }
    system("pause");
    return 0;
}