目录
目录
1. 非类型模板参数
如果我们对象的成员变量是一个数组,要开辟100个单位空间,或者开辟1000的空间,可以用宏定义即define;缺点是如果同时开辟100和1000,定义的宏不够用(不灵活)
#define N 1000
template<class T=int>
class Array
{
public:
private:
T _a[N];
};
int main()
{
Array<int> a1;//100
Array<int> a2;//1000
return 0;
}
模板参数分: 类型模板形参,非类型模板形参。
类型模板形参:出现在模板参数列表中,跟在class之后的参数类型名称。
非类型模板形参,就是用一个常量作为类(函数)模板的一个参数,在类(函数)模板中可将该参数当成常量来使用。
使用非类型模板参数
- 非类型模板参数一定是整形常量(不能是浮点型,字符串),模板参数都可以使用缺省值
// 类型模板参数
// 非类型模板参数 -- 整形常量
template<class T=int,size_t N=100>
class Array
{
public:
private:
T _a[N];
};
int main()
{
Array<int, 100> a1;
Array<int,1000> a2;
return 0;
}
int main()
{
Array<int, 100> a1;
Array<int,1000> a2;
return 0;
}
2.模板的特化(特殊化处理)
1.函数模板的特化
首先我们来看下面这对,比较2数是否相等的代码(相等返回1,不等返回0)
template<class T>
bool IsEqual(const T& left, const T& right)
{
return left == right;
}
int main()
{
int a = 1;
int b = 1;
cout << IsEqual(a, b) << endl;
double c = 1.1;
double d = 1.1;
cout << IsEqual(c, d) << endl;
const char p1[] = "hello";
const char p2[] = "hello";
cout<< IsEqual(p1,p2) << endl;
const char* p3 = "hello";
const char* p4 = "hello";
cout << IsEqual(p3, p4);
return 0;
}
结果
思想
特化后代码
template<class T>
bool IsEqual(const T& left, const T& right)
{
return left == right;
}
bool IsEqual(const char*& left, const char*& right)
{
return strcmp(left, right) == 0;
}
int main()
{
int a = 1;
int b = 1;
cout << IsEqual(a, b) << endl;
double c = 1.1;
double d = 1.1;
cout << IsEqual(c, d) << endl;
const char p1[] = "hello";
const char p2[] = "hello";
cout<< IsEqual(p1,p2) << endl;
const char* p3 = "hello";
const char* p4 = "hello";
cout << IsEqual(p3, p4);
return 0;
}
函数模板特化的特性
- 必须要先有一个基础的函数模板
- 关键字template后面接一对空的尖括号<>
- 函数名后跟一对尖括号,尖括号中指定需要特化的类型
- 函数形参表: 必须要和模板函数的基础参数类型完全相同,如果不同编译器可能会报一些奇怪的错误。
2.类模板的特化
模板的全特化:是将模板参数列表中所有的参数都确定化
template<class T1, class T2,class T3>
class Date
{
public:
Date() { cout << "Date<T1, T2, T3>" << endl; }
private:
T1 _year;
T2 _month;
T3 _day;
};
// 假设针对T1 T2是 int int想做一些特殊化那么怎么办 ? -- 类模板特化
// -- 全特化
template<>
class Date < int, int, int >
{
public:
Date() { cout << "Date<int, int, int >" << endl; }
};
模板的偏特化:是将模板参数列表中一部分参数都确定化
template<class T1, class T2,class T3>
class Date
{
public:
Date() { cout << "Date<T1, T2, T3>" << endl; }
private:
T1 _year;
T2 _month;
T3 _day;
};
// 将第二个和第三个参数特化为int --偏特化
template <class T1>
class Date < T1, int, int >
{
public:
Date() { cout << "Date<T1, int, int >" << endl; }
};
模板还可以指针或者引用特化
template <class T1, class T2,class T3>
class Date <T1*, T2*,T3*>
{
public:
Date() { cout << "Date<T1*, T2*, T3* >" << endl; }
};
template <class T1, class T2,class T3>
class Date < T1&, T2& , T3& >
{
public:
Date() { cout << "Date<T1&, T2& ,T3& >" << endl; }
};
3.模板分类编译
什么是分离编译 :一个程序(项目)由若干个源文件共同实现,而每个源文件单独编译生成目标文件,最后将所有目标文件链 接起来形成单一的可执行文件的过程称为分离编译模式。
为什么不支持分离编译
解决方式1
在定义里面显示实例化,那么就会调用对应的,但是每一个不同的类型就需要写一个,麻烦
#include"template.h"
template<class T>
T Add(const T& left, const T& right)
{
return left + right;
}
void func(int a, int b)
{
cout << a << endl;
cout << b << endl;
}
template<>
int Add<int>(const int& left, const int& right);
template<>
double Add<double>(const double& left, const double& right);
解决方法2
声明定义放一起,不麻烦
#pragma once
#include <iostream>
using namespace std;
// 模板函数
template<class T>
T Add(const T& left, const T& right);
template<class T>
T Add(const T& left, const T& right)
{
return left + right;
}
//普通函数
void func(int a, int b);
4.总结
什么是按需实例化
- f3没调用就不会实例化生成;
template<class T>
class AT
{
public:
void f1(const T& x)
{
cout << "void f1()" << endl;
}
void f2(const T& x)
{
cout << "void f2()" << endl;
}
void f3(const T& x)
{
cout << "void f3()" << endl
}
};
int main()
{
AT<int> at1;
AT<double> at2;
AT<char> at3;
at1.f1(0);
at2.f1(1.1);
at3.f2(1.1);
return 0;
}