模板参数分为类型形参和非类型形参,非类型形参就是将一个常量作为模板形参,将该参数当做常量来用。
注意:
(1)字符串,浮点数,类对象是不能作为非类型模板参数的
(2)非类型的模板参数必须在编译期间就能确认结果
在原模板类的基础上,针对特殊类型所进行特殊化的实现方式。
通常情况下,使用模板可以实现一些与类型无关的代码,但对于一些特殊类型的可能会得到一些错误的结 果,需要特殊处理,比如:实现了一个专门用来进行小于比较的函数模板:
// 函数模板 -- 参数匹配
template<class T>
bool Less(T left, T right)
{
return left < right;
}
int main()
{
cout << Less(1, 2) << endl; // 可以比较,结果正确
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;
}
可以看到,Less绝对多数情况下都可以正常比较,但是在特殊场景下就得到错误的结果。上述示例中,p1指 向的d1显然小于p2指向的d2对象,但是Less内部并没有比较p1和p2指向的对象内容,而比较的是p1和p2指 针的地址,这就无法达到预期而错误。
步骤:
(1)必须有一个基础的函数模板
(2)template后面接一个空的<>
(3)函数名后面跟着一个<>,里面装要特化的具体类型
(4)特化的函数参数列表必须跟模板函数的基础参数类型完全一样。
将参数列表中的参数全部确定化
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 TestVector()
{
Data<int, int> d1;
Data<int, char> d2;
}
(a)将模板参数列表一部分确定下来
//将第二个参数特化为int
template <class T1>
class Data<T1, int>
{
public:
Data()
{
cout<<"Data" <<endl;
}
private:
T1 _d1;
int _d2;
};
(b)参数更进一步的限制
//两个参数偏特化为指针类型
template <typename T1, typename T2>
class Data <T1*, T2*>
{
public:
Data()
{
cout<<"Data" <<endl;
}
private:
T1 _d1;
T2 _d2; };
//两个参数偏特化为引用类型
template <typename T1, typename 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;
}
全特化>偏特化>原模板
template<class T1,class T2>
class Data
{
public:
Data()
{
cout << "Date<T1,T2>" << endl;
}
};
//全特化
template<>
class Data<int, char>
{
public:
Data()
{
cout << "Date<int,char>" << endl;
}
private:
int _a1;
char _a2;
};
template<>
class Data<int, int>
{
public:
Data()
{
cout << "Date<int,int>" << endl;
}
private:
int _a1;
int _a2;
};
//偏特化1:特化部分参数
template<class T1>
class Data<T1, int>
{
public:
Data()
{
cout << "Date<T1,int>" << endl;
}
private:
T1 _a1;
int _a2;
};
//偏特化2:对参数类型进行一定限制,比如:限制是指针或引用等
template<class T1,class T2>
class Data<T1*, T2*>
{
public:
Data()
{
cout << "Date<T1*,T2*>" << endl;
}
private:
T1* _a1;
T2* _a2;
};
//两个参数偏特化为引用类型
template<typename T1,typename T2>
class Data<T1&, T2*>
{
public:
Data()
{
cout << "Date<T1&,T2*>" << endl;
}
};
int main()
{
Data<int, int> d1;
Data<int, char> d2;
Data<char, int> d3;
Data<char*, int*> d4;
Data<int*, int*> d5;
Data<int&, int*> d6;
Data<int*, int&> d7;
return 0;
}
运行结果:
一个程序(项目)由若干个源文件共同实现,而每个源文件单独编译生成目标文件,最后将所有目标文件链 接起来形成单一的可执行文件的过程称为分离编译模式。
// Add.h
template<class T>
T Add(const T& left, const T& right);
// Add.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;
}
运行结果:
究其原因是啥呢?
其实就是在cpp文件中,当调用Add函数时并没有找到对Add函数模板的实例化,那为啥找不到呢?
1.那是因为函数模板其实并不是函数,他不会占用内存,最终生成的函数才会占用内存,所以在编译过程中,编译器会参考模板来生成函数。 2.回到这个问题,在main.cpp中,编译器会去找Add(int,int)的定义,但是在Add.h中只找到了模板函数的声明,却没找到定义,这时,编译器会记录一下,会在后面链接时再尝试去找,但是在Add.cpp中找时,并没有找到Add(int,int)的定义,只有一个未实例化的模板定义,这样就出现了最终的链接错误。
将函数模板的声明和定义放到一个文件里面。
模板复用了代码,节省资源,更快的迭代开发,增加了代码的灵活性
模板会导致代码的膨胀问题,也会导致编译的时间变长,且出现编译错误时,错误信息凌乱,不易定位错误
总结
好了,到这里今天的知识就讲完了,大家有错误一点要在评论指出,我怕我一人搁这瞎bb,没人告诉我错误就寄了。
祝大家越来越好,不用关注我(疯狂暗示)