文章目录
一、模板
1、模板简介
C++提供了
函数模板，所谓函数模板实际上是建立一个通用函数，其函数类型和形参类型不具体制定，用一个虚拟的类型来代表。这个通用函数就成为函数模板。凡是
函数体相同的函数都可以用这个模板代替，不必定义多个函数，只需在模板中定义一次即可。 在调用函数时系统会根据实参的类型来取代模板中的虚拟类型，从而头现不同函数的功能；在使用时，编译器由模板
自动生成函数时，会用具体的类型名对模板中所有的类型参数进行替换，其他部分则原封不动地保留。同一个类型参数只能替换为同一种类型；C++提供两种模板机制：
函数模板和类模板；类属 - 类型参数化，又称
参数模板。
模板把
函数或类要处理的数据类型参数化，表现为参数的多态性，成为类属。模板用于表达逻辑结构相同，但具体数据元素类型不同的数据对象的通用行为。
2、三个关键字
template
该关键一出现，即告知编译器后面将进入泛型编程；
typename与class
用于
声明泛型编程的类型
2.1 class和typename有什么不同
两者的
意义完全相同；但有些情况需要使用
typename：
- 使用
嵌套依赖类型，就必须在紧临它的前一个位置放上关键字；- 告知
类型名称，而不是成员函数或者成员变量；
class MyArray
{
public：
typedef int LengthType;
.....
}
template<class T>
void MyMethod( T myarr )
{ // 类型名称
typedef typename T::LengthType LengthType;
LengthType length = myarr.GetLength;
}
3、模板的局限性
若使用比较类是否
相等，则正常的比较方法不能满足，则需要通过具体化自定义数据类型来解决；具体化的函数必须和前面的函数模板一样。
template<> 数据类型 函数名<数据类型>(数据类型 参数名){}来重写
4、模板的实例化
编译器由模板
自动生成函数的过程；由模板实例化而得到的函数称为模板函数；
- 在某些编译器中，模板只有在
被实例化时，编译器才会检查其语法正确性。如果程序中写了一个模板却没有用到，那么编译器不会报告这个模板中的语法错误；
二、函数模板
template <class 类型参数1, class类型参数2, ...>
返回值类型 模板名(形参表)
{
函数体
}
1、基本使用
template<class/typename T> // 需要紧跟下面函数体
void swap(T &a, T&b){
// 函数实现
}
int main() {
// 调用
int a = 10;
int b = 20;
swap(a, b); // 自动推导
swap<int>(a, b); // 显示调用
return 0;
}
普通函数与函数模板区别
函数模板不能进行
隐式转换；
自动类型必须严格匹配；
显示类型指定时，能够进行隐式类型转换；若重载优先使用
普通函数；
- 可以通过空模板实参列表限定编译器只匹配模板；
若函数模板可以产生
更好的匹配，那么优先调用函数模板；当多种类型参数时，无法
自动推导返回值类型；
2、机制刨析
2.1 实现机制
编译器并
不是把函数模板处理成能够处理任何类型的函数；编译器会对函数模板进行
两次编译，
在
声明的地方对模板代码本身进行编译；在
调用时参数替换后的；编译器在编译到
调用函数模板的语句时，会根据实参的类型判断该如何替换模板中的类型参数；函数模板通过
具体类型产生不同的函数；
3、函数模板特化
#include <iostream>
using namespace std;
/** 泛化模板 */
template
< typename T >
bool Equal(T a, T b)
{
cout << "bool Equal(T a, T b)" << endl;
return a == b;
}
/** 特化模板 */
template
< >
bool Equal<double>(double a, double b)
{
const double delta = 0.00000000000001;
double r = a - b;
cout << "bool Equal<double>(double a, double b)" << endl;
return (-delta < r) && (r < delta);
}
/** 函数 */
bool Equal(double a, double b)
{
const double delta = 0.00000000000001;
double r = a - b;
cout << "bool Equal(double a, double b)" << endl;
return (-delta < r) && (r < delta);
}
int main()
{
cout << Equal( 1, 1 ) << endl;
cout << Equal( 0.001, 0.001 ) << endl;
cout << Equal<>( 0.001, 0.001 ) << endl;
return 0;
}
三、类模板
- 调用时
成员函数才被创建；- 主要用于
存储和组织数据元素；- 只能
显示指定，无法自动推导；
1、类模板编译时
- 编译器对
类模板的处理方式和函数模板相同；
- 从
类模板通过具体类型产生不同的类；- 在
声明的地方对类模板代码本身进行编译；- 在
使用的地方对参数替换后的代码进行编译
2、表达式参数
- 具有
整型或枚举的值；- 指向
对象的指针或到对象的引用；- 指向
函数的指针或到函数的引用；- 指向类成员函数的
指针；
> 提供参数不能让类得到区分，下面1、2会导致重定义
/** 1、泛化*/
template<class NameType, class AgeType>
class Person{
Person(NameType name, AgeType age){
this->name = name;
this->age = age;
}
NameType name;
AgeType age;
};
/** 2、泛化*/
template<class NameType, class AgeType = float>
class Person{
Person(NameType name, AgeType age){
this->name = name;
this->age = age;
}
NameType name;
AgeType age;
};
/** 偏特化 */
template<class NameType>
class Person<NameType, int>{
Person(NameType name, int age){
this->name = name;
this->age = age;
}
NameType name;
int age;
};
/** 全特化 */
template<>
class Person<string, int>{
Person(string name, int age){
this->name = name;
this->age = age;
}
string name;
int age;
};
3、 类模板做函数参数
- 做普通函数参数，可指定传入类型；
- 做函数模板，参数模板化；
- 整体类型化；
template<class NameType, class AgeType=int>
class Person(){
Person(NameType name, AgeType age){
this->name = name;
this->age = age;
}
NameType name;
AgeType age;
}
// 指定传入参数
void show1(Person<string, int>p){
cout<< p.name << p.age <<endl;
}
void test1(){
show1();
}
// 参数模板化
template<class T1, class T2>
void show2(Person<T1, T2> &p){
cout<< p.name << p.age <<endl;
}
// 整体类型化
template<class T>
void show3(T &p){
cout<< p.name << p.age <<endl;
}
void test(){
Person <string, int>p("小明", 20);
show3(p);
}
4、注意事项
4.1 查看模板类型
typeid(需要查看的对象).name()
4.2 继承
- 模板中，继承需要
指定类型，否则无法分配内存；
4.3 类外实现成员函数
模板函数成员的
定义由模板参数专门化后跟函数定义组成。函数标识符通过类模板的
类名称和模板参数限定；
4.4 类模板份文件
将类模板的所有都写在
.hpp文件内；
4.5 友元函数
类内实现：
frinend 返回值类型 函数名 (参数)；
类外实现：
先声明类以及友元函数；
在类内声明友元函数需要利用参数列表；
friend 返回值类型 函数名<>(参数);
5、类模板特化
以统一的方式使用
内模板和特化类；编译器
自动优先选择特化类；特化只是模板的
分开实现，本质上是同一个类模板；特化类模板的使用方式是
统一的，必须显示指定每一个类型参数；
#include <iostream>
using namespace std;
/**
*/
template
< typename T1, typename T2 >
class Test
{
public:
void add(T1 a, T2 b)
{
cout << "void add(T1 a, T2 b)" << endl;
cout << a + b << endl;
}
};
/** 关于指针的特化实现 */
template
< typename T1, typename T2 >
class Test < T1*, T2* >
{
public:
void add(T1* a, T2* b)
{
cout << "void add(T1* a, T2* b)" << endl;
cout << *a + *b << endl;
}
};
/** 当 Test 类模板的两个类型参数完全相同时，使用这个实现 */
template
< typename T >
class Test < T, T >
{
public:
void add(T a, T b)
{
cout << "void add(T a, T b)" << endl;
cout << a + b << endl;
}
void print()
{
cout << "class Test < T, T >" << endl;
}
};
/* 当 T1 == void* 并且 T2 == void* 时 */
template
< >
class Test < void*, void* >
{
public:
void add(void* a, void* b)
{
cout << "void add(void* a, void* b)" << endl;
cout << "Error to add void* param..." << endl;
}
};
int main()
{
Test<int, float> t1;
Test<long, long> t2;
Test<void*, void*> t3;
t1.add(1, 2.5);
cout << endl;
t2.add(5, 5);
t2.print();
cout << endl;
t3.add(NULL, NULL);
cout << endl;
Test<int*, double*> t4;
int a = 1;
double b = 0.1;
t4.add(&a, &b);
return 0;
}
610
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
