C++深度解析(48)—类模板深度剖析

1.多参数类模板

• 类模板可以定义任意多个不同的类型参数

template <typename T1,typename T2>
class Test
{
public:
    void add(T1 a,T2 b);
}
​```
Test<int,float> t;

• 类模板可以被特化
  • 指定类模板的特定实现，即特化是一个类模板其参数特殊情况时的分开实现
  • 部分类型参数必须显示指定，如class <T, T>
  • 根据类型参数分开实现类模板

 

• 类模板的特化类型 
  • 部分特化－用特定规则约束类型参数 
  • 完全特化－完全显示指定类型参数 

• 类模板特化注意事项：
  • 特化只是模板的分开实现（即，当类模板参数比较特殊时须分开来实现），本质上是同一个类模板
  • 特化类模板的使用方式是统一的，必须显式指定每一个类型参数，如class<T, T>严格匹配参数类型

2.编程实验

• 类模板的特化  

#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;
	}
};

// 类模板特化为两个参数相同的情况（因参数仍是泛型，故称为部分特化）
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;
	}
};

// 完全特化，当两个参数具体的类型（如int，void*），而不是泛型类型时
template <> // 这里为空，因为没有泛型了，只有实际类型
class Test <void *, void *> // 特化时，这里须显示指定参数类型（这里特化为void*）
{
public:
	void add(void *a, void *b)
	{
		cout << "void add (void *a, void *b)" << endl;
		cout << "Error to add void* param" << endl;
	}
};

// 重定义（虽然可以完成与完全特化的类模板一样的功能，但本质上这是一个新的类）
class Test_Void
{
public:
	void add(void *a, void *b)
	{
		cout << "void add (void *a, void *b) new Method" << endl;
		cout << "Error to add void* param" << endl;
	}
};

int main()
{
	Test<int, float> t1;   // template <typename T1, typename T2>, 直接来自类模板
	//一般的类模板（非特化的类模板）
	t1.add(1, 2.5);
	cout << endl;

	Test<long, long> t2;   //class Test<T, T>,两个参数类型一致的特化模板
	//特化为两个相同参数类型
	t2.add(5, 5);
	t2.print();
	cout << endl;

	Test<void *, void *> t3; // 选择完全特化的模板class Test<void *, void *>,而不是class Test<T1 *, T2 *>
	//特化为两个void*类型
	t3.add(NULL, NULL);
	cout << endl;

	Test<int *, double *> t4; //class Test<T1 *, T2 *>,选择指针类型的特化模板
	//特化的两个是指针类型
	int a = 1;
	double b = 0.1;
	t4.add(&a, &b);
	cout << endl;

	//重定义
	Test_Void t5;
	t5.add(NULL, NULL); // 这就是一个新的类了。不是特化模板。

	system("pause");
	
	return 0;
}

• 运行结果：

3.特化的深度分析

• 重定义和特化的不同
  • 重定义 
    • 一个类模板和一个新类（重定义本质上是两个类模板）
    • 使用的时候需要自己考虑如何选择的问题。
  • 特化 
    • 以统一的方式使用类模板和特化类，特化后本质上仍然是同一个类模板，只是分开来实现而己
    • 编译器自动优先选择特化类

4.函数模板的特化

• 函数模板只支持类型参数完全特化

#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)   //函数名后面必须指定参数的类型（如double）
{
	const double delta = 0.00000000000001;
	double r = a - b;   // 因为double类型的比较不是精确的，所以只能采取范围的比较

	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;  // 调用特化的函数模板，因为<>表示只匹配函数模板
	                                        // 又因参数而优先选择特化模板，故调用Equal(double a, double b)
	cout << Equal<double>(0.001, 0.001) << endl; // 显示指定调用特化模板
	cout << Equal(0.001, 0.001) << endl;     // 优先选择普通函数(编译器的选择)，然后特化模板，最后一般模板。

	system("pause");
	
	return 0;
}

• 运行结果：

5.工程中的建议

• 当需要重载函数模板时，优先考虑使用模板特化；当模板特化无法满足需求，再考虑使用函数重载。为什么要优先考虑使用模板特化：因为函数模板和模板特化本质上是一个函数，而函数重载又是一个新的函数了。
• 总结：
  • 编译器优先选择普通函数(编译器的选择)，然后特化模板，最后一般模板

6.小结

• 类模板可以定义任意多个不同的类型参数
• 类模板可以被部分特化和完全特化
• 特化的只是模板的分开实现，本质是同一个模板
• 函数模板只支持完全特化
• 工程中使用模板特化代替类（函数）重定义（可能是节省资源）