文章目录
- 一、模板参数缺省值
- 二、非类型模板参数
- 三、模板的特化
- 四、模板的分离编译
一、模板参数缺省值
给模板初始值与给函数初始值类似，当需要给一部分缺省值时，参数缺省值必须从右向左给，中间不能留着参数不给缺省值。
template< class T = int>
void test01()
{
cout << "T： "<<typeid(T).name() << endl;
}
template<class T1, class T2 = int>
void test02()
{
cout << "T1： "<<typeid(T1).name() << endl;
cout << "T2： "<<typeid(T2).name() << endl;
}
int main()
{
//使用默认缺省值
test01();
//指定
test01<double>();
//部分缺省
test02<double>();
//全部指定
test02<double,double>();
return 0;
}
二、非类型模板参数
模板参数分类类型形参与非类型形参。
类型形参即：出现在模板参数列表中，跟在class或者typename之类的参数类型名称。
非类型形参，就是用一个常量作为类(函数)模板的一个参数，在类(函数)模板中可将该参数当成常量来使用。
如：模板静态数组
//T为类型，N为常量
template< class T, size_t N>
class Arr
{
public:
Arr()
{
cout << N << endl;
}
private:
int arr[N] = {0};
};
int main()
{
Arr<int, 10> arr;
return 0;
}
注意：
- 浮点数、类对象以及字符串是不允许作为非类型模板参数的。
- 非类型的模板参数必须在编译期就能确认结果。
三、模板的特化
1、函数模板特化
有一些场景只通过通用的函数模板是无法求正确答案的。
如：
template< class T>
void Sub(T a,T2 )
{
cout << a - b << endl;
}
int main()
{
int a = 20;
int b = 10;
//没有问题
Sub(a, b);
//出错了，求的是指针的差
Sub(&a, &b);
return 0;
}
对于上面情况可以通过函数模板特化解决
函数模板的特化步骤：
- 必须要先有一个基础的函数模板
- 关键字template后面接一对空的尖括号<>
- 函数名后跟一对尖括号，尖括号中指定需要特化的类型
- 函数形参表: 必须要和模板函数的基础参数类型完全相同，如果不同编译器可能会报一些奇怪的错误。
template< class T>
void Sub(T a,T b)
{
cout << a - b << endl;
}
template<>
void Sub<int*>(int* a, int* b)
{
cout << *a - *b << endl;
}
int main()
{
int a = 20;
int b = 10;
//没有问题
Sub(a, b);
//使用特化的模板
Sub(&a, &b);
return 0;
}
另一种解决方法就是直接写一个该类型的函数，这个函数会与模板函数构成重载，并且符合的话会被优先使用
template< class T>
void Sub(T a,T b)
{
cout <<"void Sub(T a,T b)"<< endl;
}
void Sub(int* a, int* b)
{
cout <<"void Sub(int* a, int* b)" << endl;
}
int main()
{
int a = 20;
int b = 10;
//使用模板
Sub(a, b);
//使用现成函数
Sub(&a, &b);
return 0;
}
2、类模板特化
类特化的方式与函数模板特化参不多，就是原本在函数名指定改为在类名指定。
(1)全特化
全特化就是全部参数被指定。
template<class T1,class T2>
class A
{
public:
A() { cout<<"class A" << endl; }
};
template<>
class A<int,char>
{
public:
A() { cout << "class A<int,char>" << endl; }
};
int main()
{
//调用通用模板
A<int, int> a1;
//使用特化模板
A<int, char> a2;
return 0;
}
(2)偏特化
只特化一部分参数:
限定参数:
template<class T1, class T2>
class A
{
public:
A() { cout << "class A" << endl; }
};
template<class T1,class T2>
class A<T1*, T2*>
{
public:
A() { cout << "class A<T1*, T2*>" << endl;
cout <<"T1:" << typeid(T1).name() << endl;
}
};
template<class T1, class T2>
class A<T1&, T2&>
{
public:
A() { cout << "class A<T1&, T2&>" << endl;
cout << "T1:" << typeid(T1).name() << endl;
}
};
int main()
{
//调用通用模板
A<int, int> a1;
//使用特化模板
//虽然传的是int*,但是T1还是int
A<int*, int*> a2;
//虽然传的是double&,但是T1还是double
A<double&, double&> a3;
return 0;
}
四、模板的分离编译
1、关于类模板实例化：
例：
template<class T>
class A
{
public:
//重命名
typedef T TYPE;
};
template<class T>
void test03()
{
//会检查语法等
A<T>::TYPE a = 10;
}
int main()
{
test03<int>();
return 0;
}
在没有被实例化时，编译器只会对函数进行语法等检查，不会查看类内部细节，如上面的A<T>::TYPE a = 10 TYPE是类型按道理来说没有问题，但是编译器在检查到这里是就会出现歧义，不知道TYPE是类型还是静态变量，所以就会报错。
对于上述这种情况，我们可以加一个 typename 关键字来说明TYPE是一个类型，这样就不会报错了。
typename A<T>::TYPE a = 10;
2、什么是分离编译
一个程序（项目）由若干个源文件共同实现，而每个源文件单独编译生成目标文件，最后将所有目标文件链
接起来形成单一的可执行文件的过程称为分离编译模式。
3、为什么模板分离编译会报错
