赞
踩
首先,来看一个问题:如何实现一个通用的交换函数呢?
有人可能会说,可以用函数重载!
void Swap(int& left, int& right) { int tmp = left; left = right; right = tmp; } void Swap(double& left, double& right) { double tmp = left; left = right; right = tmp; } void Swap(char& left, char& right) { char tmp = left; left = right; right = tmp; } ......
但是,看看以上函数重载的代码,我们可以发现几个缺陷:
所以,C++为了应对这种情况,提出了泛型编程,并且引入了模板的概念。
泛型编程:编写与类型无关的通用代码,是代码复用的一种手段。模板是泛型编程的基础。
模板,又分为函数模板和类模板。
函数模板代表了一个函数家族,该函数模板与类型无关,在使用时被参数化,根据实参类型产生函数的特定类型版本。
使用模板后,一个通用的交换函数如下:
template<typename T>
void Swap(T& left, T& right)
{
T tmp = left;
left = right;
right = tmp;
}
template<typename T1, typename T2,…, typename Tn>
返回值类型 函数名(参数列表){}
注意:typename是用来定义模板参数关键字,也可以使用class(切记:不能使用struct代替class)
函数模板是一个蓝图,它本身并不是函数,是编译器用使用方式产生特定具体类型函数的模具。所以其实模板就是将本来应该我们做的重复的事情交给了编译器。
在编译器编译阶段,对于模板函数的使用,编译器需要根据传入的实参类型来推演生成对应类型的函数以供调用。比如:当用double类型使用函数模板时,编译器通过对实参类型的推演,将T确定为double类型,然后产生一份专门处理double类型的代码,对于int类型、char类型也是如此。
用不同类型的参数使用函数模板时,称为函数模板的实例化。模板参数实例化分为:隐式实例化和显式实例化。
隐式实例化:让编译器根据实参推演模板参数的实际类型
template<class T>
T Add(const T& left, const T& right)
{
return left + right;
}
int main()
{
int a1 = 10, a2 = 20;
double d1 = 10.0, d2 = 20.0;
Add(a1, a2);
Add(d1, d2);
Add(a1, d1);//err
}
注意:上述第三条函数调用语句是错误的!因为编译器不知道模板参数究竟是int还是double,所以,有两种解决方式:
显式实例化:在函数名后的<>中指定模板参数的实际类型
int main()
{
int a = 10;
double b = 20.0;
// 显式实例化
Add<int>(a, b);
return 0;
}
int Add(int left, int right)
{
return left + right;
}
template<class T> T Add(T left, T right)
{
return left + right;
}
void Test()
{
Add(1, 2); // 与非模板函数匹配
Add<int>(1, 2); // 与模板函数匹配
}
int Add(int left, int right) { return left + right; } template<class T1, class T2> T1 Add(T1 left, T2 right) { return left + right; } void test() { Add(1, 2); // 与非函数模板完全匹配 Add(1, 2.0); // 模板函数可以生成更加匹配的版本 }
template<class T1, class T2, …, class Tn>
class 类模板名 {};
比如之前学习过的vector类:
template<class T>
class vector
{
private:
T* _start;
T* _finish;
T* _end_of_storage;
};
类模板实例化与函数模板实例化不同,类模板实例化需要在类模板名字后跟<>,然后将实例化的类型放在<>中即可,类模板名字不是真正的类,而实例化的结果才是真正的类。
void test()
{
vector<int> v1;
vector<double> v2;
}
模板参数,分为类型形参与非类型形参。
比如,定义一个模板类型的静态数组。
template<class T, size_t N = 10>
class array
{
public:
T& operator[](size_t index){return _array[index];}
const T& operator[](size_t index)const{return _array[index];}
size_t size()const{return _size;}
bool empty()const{return 0 == _size;}
private:
T _array[N];
size_t _size;
};
注意:非类型形参,必须是整型常量!
通常,使用模板可以支持与类型无关的代码,但是在特殊情况下,对于某些特殊类型需要特殊处理,所以这就是模板的特化。
比如:实现了一个专门用来进行小于比较的函数模板
template<class T> bool Less(T left, T right) { return left < right; } int main() { Date d1(2022, 7, 7); Date d2(2022, 7, 8); cout << Less(d1, d2) << endl; // 可以比较,结果正确 Date* p1 = &d1; Date* p2 = &d2; cout << Less(p1, p2) << endl; // 可以比较,结果错误 return 0; }
从上述代码可知,针对Date*类型,函数模板的比较就出错了,这时候就需要进行模板特化。
模板特化,分为函数模板特化和类模板特化。
细节:
template<class T>
bool Less(T left, T right)
{
return left < right;
}
template<>
bool Less<Date*>(Date* left, Date* right)
{
return *left < *right;
}
话虽如此,不知道小伙伴有没有发现,其实函数模板特化还不如直接重载一份对应类型的函数。
bool Less(Date* left, Date* right)
{
return *left < *right;
}
函数重载的方式,反而代码简洁,可读性高,所以函数模板不建议特化。遇到不能处理的类型,直接重载一份对应类型的函数即可。
全特化,是将模板参数列表中所有的参数都确定化。
template<class T1, class T2> class Data { public: Data() {cout<<"Data<T1, T2>" <<endl;} private: T1 _d1; T2 _d2; }; //全特化 template<> class Data<int, char> { public: Data() {cout<<"Data<int, char>" <<endl;} private: int _d1; char _d2; }; void test() { Data<int, int> d1;// 调用基础模板 Data<int, char> d2;// 调用全特化模板 }
偏特化:任何针对模版参数进一步进行条件限制设计的特化版本。
template<class T1, class T2>
class Data
{
public:
Data() {cout<<"Data<T1, T2>" <<endl;}
private:
T1 _d1;
T2 _d2;
};
针对以上基础模板,我们有两种偏特化方式:
template<class T1>
class Data<T1, int>
{
public:
Data() {cout<<"Data<T1, int>" <<endl;}
private:
T1 _d1;
int _d2;
};
template<class T1, class T2> class Data<T1*, T2*> { public: Data() {cout<<"Data<T1*, T2*>" <<endl;} private: T1* _d1; T2* _d2; }; template<class T1, class T2> class Data<T1&, T2&> { public: Data(const T1& d1, const T2& d2) : _d1(d1) , _d2(d2) { cout << "Data<T1&, T2&>" << endl; } private: const T1& _d1; const T2& _d2; };
注意:
偏特化测试结果如下:
void test()
{
Data<double, int> d1; // 调用特化的int版本
Data<int, double> d2; // 调用基础的模板
Data<int*, int*> d3; // 调用特化的指针版本
Data<int&, int&> d4(1, 2); // 调用特化的引用版本
}
总结:模板特化,对于函数模板用处不大(因为有函数重载),而对于类模板的用处非常大,可以针对特殊类型进行特殊处理。
一个程序(项目)由若干个源文件共同实现,而每个源文件单独编译生成目标文件,最后将所有目标文件链接起来形成单一的可执行文件的过程称为分离编译模式。
假设模板的声明与定义分离开,在头文件中进行声明,源文件中完成定义:
// a.h template<class T> T Add(const T& left, const T& right); // a.cpp template<class T> T Add(const T& left, const T& right) { return left + right; } // main.cpp #include"a.h" int main() { Add(1, 2); Add(1.0, 2.0); return 0; }
分析:
模板复用了代码,节省资源,更快的迭代开发,C++的标准模板库(STL)因此而产生,同时还增强了代码的灵活性。
Copyright © 2003-2013 www.wpsshop.cn 版权所有,并保留所有权利。