【C++基础十】泛型编程(模板初阶)

1.什么是模板

void swap(int& a, int& b)
{int tmp = 0;tmp = a;a = b;b = tmp;
}void swap(double& a, double& b)
{double tmp = 0;tmp = a;a = b;b = tmp;
}void Swap(char& a, char& b)
{char temp = a;a = b;b = temp;
}

正常来说，对于不同类型的变量进行交换，需要实现不同的swap函数，这样实现有些太繁琐了
为了解决相似函数的不同调用问题，C++提出泛型编程，编写与类型无关的通用代码，实现代码复用，即模板
模板主要分为函数模板和类模板

模板格式：

template <typename T1, typename T2,…,typename Tn>//一次性可以定义多个类型

typename是用来定义模板参数的关键字，也可以使用class，两者目前是没区别的，但是由于STL大部分用的class，所以建议使用class

template <class T1, class T2,…,class Tn>//一次性可以定义多个类型

swap函数模板：

template <class T>
void Swap(T& a, T& b)
{T temp = a;a = b;b = temp;
}

写好上面的代码后，传int类型的变量进去，T就会被实例化为int，以此类推

2.函数模板的实例化：

2.1隐式实例化

实参传给形参后，编译器自动推演模板类型

template <class T>
T add(T& left, T& right)
{return left + right;
}
int main()
{int a = 1;int b = 2;double p1 = 1.0;double p2 = 2.0;//同类型进行可以正常运行add(a, b);//自动推演类型为intadd(p1, p2);//自动推演类型为double//-----------addd(a, p1);//a与p1是不同类型，会报错return 0;
}

不同类型去模板推演会出现歧义，a传过去将T推演成int，而p1传过去把T推演成double，T无法确定推演int还是double

2.2显示实例化

在函数名后的<>中指定模板参数的类型

template <class T>
T Add(const T& left, const T& right)
{return left + right;
}
int main()
{int a1 = 10, a2 = 20;double d1 = 10.1, d2 = 20.1;Add<int>(a1, d1);//显示实例化
}

指定T的类型为int ，因为d1是double类型，所以在传参时会发生隐式类型转换变成int，若无法转换成功编译器将会报错

3.函数模板参数的匹配规则

模板函数和普通函数可以同时存在
通过调试可以发现调用的是普通函数，因为成本更低，使用模板还需要实例化生成代码，而普通函数可以直接使用

// 专门处理int的加法函数
int Add(int left, int right)
{return left + right;
}
// 通用加法函数
template<class T>
T Add(T left, T right)
{return left + right;
}int main()
{Add(10,20)//调用非模板Add(11.1,6.3);//调用模板return 0;
}

在调用函数时若参数和非模板函数匹配，那么编译器会优先调用非模板函数
若非模板函数不匹配或模板函数更匹配，那么编译器会优先调用模板函数

4.什么是类模板

template <class T1, class T2, …, class Tn>//和函数模板类似，类模板也可以同时定义多个模板参数
class 类模板名
{// 类内成员定义
};

有typedef的存在为什么还有类模板？

typedef int STdatatype;
class stack
{
private:STdatatype* _a;size_t top;size_t capacity;
};int main()
{stack s1;//想要S1存储intstack s2;//想要S2存储doublereturn 0;
}

如果想要改变栈储存的类型可以选择改变typedf定义的类型
但是若想要两个栈分别储存不同的数据类型typedef做不到
两份类的代码几乎是一致的，但若想达到目的就需要再拷贝一份出来，就太繁琐了

一个简易的顺序表：
所有实际类型需要出现的地方用T代替

template<class T>
class Vector
{ 
public :Vector(size_t capacity = 10): _Data(new T[capacity]), _size(0), _capacity(capacity){}T& operator[](size_t pos){assert(pos < _size);return _Data[pos];}
private:T* _Data;size_t _size;size_t _capacity;
};

5.类模板的实例化

类模板只能显示实例化，这样就可以达到s1存储int,S2存储double

template <class T>
class stack
{
public:stack(int capacity=4){_a = new T[capacity];_top = 0;_capacity = capacity;}~stack(){delete[]_a;_capacity = _top = 0;}
private:T* _a;size_t top;size_t capacity;
};int main()
{stack <int>s1;//想要S1存储intstack <double>s2;//想要S2存储doublereturn 0;
}

6.声明和定义分离

对于模板，vector是类名而不是类型，加上实例化的模板参数后vector<T>才是类型
析构函数在类外面定义 ，需要使用类型 vector < T>，而T作为模板需要调用template < class T >
必须要再加上类模板template并且要指定类域

template<class T>
class Vector
{ 
public:Vector(size_t capacity = 10): _pData(new T[capacity]), _size(0), _capacity(capacity){}~Vector();//类中的声明析构函数void push_back(T x);//类中声明函数
private:T* _Data;size_t _size;size_t _capacity;
};template <class T>//析构函数在类外面定义 要加上模板
Vector<T>::~Vector()
{detele[]_pData;_pData = nullptr;_size = _capacity = 0;
}template<class T>//模板类的函数在类外定义，要加上模板
void Vector<T>::push_back(T x)
{_Date[_size] = x;_size++;
}int main()
{Vector<int> v;return 0;
}