c++ - 模板(二)

---

一、模板参数缺省值

给模板初始值与给函数初始值类似，当需要给一部分缺省值时，参数缺省值必须从右向左给，中间不能留着参数不给缺省值。

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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

二、非类型模板参数

模板参数分类类型形参与非类型形参。
类型形参即：出现在模板参数列表中，跟在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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

注意：

1. 浮点数、类对象以及字符串是不允许作为非类型模板参数的。
2. 非类型的模板参数必须在编译期就能确认结果。

三、模板的特化

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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

对于上面情况可以通过函数模板特化解决
函数模板的特化步骤：

1. 必须要先有一个基础的函数模板
2. 关键字template后面接一对空的尖括号<>
3. 函数名后跟一对尖括号，尖括号中指定需要特化的类型
4. 函数形参表: 必须要和模板函数的基础参数类型完全相同，如果不同编译器可能会报一些奇怪的错误。

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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

另一种解决方法就是直接写一个该类型的函数，这个函数会与模板函数构成重载，并且符合的话会被优先使用

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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

(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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

四、模板的分离编译

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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

在没有被实例化时，编译器只会对函数进行语法等检查，不会查看类内部细节，如上面的A<T>::TYPE a = 10 TYPE是类型按道理来说没有问题，但是编译器在检查到这里是就会出现歧义，不知道TYPE是类型还是静态变量，所以就会报错。

对于上述这种情况，我们可以加一个 typename 关键字来说明TYPE是一个类型，这样就不会报错了。

typename A<T>::TYPE a = 10;
1

2、什么是分离编译
一个程序（项目）由若干个源文件共同实现，而每个源文件单独编译生成目标文件，最后将所有目标文件链
接起来形成单一的可执行文件的过程称为分离编译模式。

3、为什么模板分离编译会报错