C++学习笔记 第59课 类模板深度刨析

1.多参数类模板

类模板可以定义任意多个不同的类型参数，其中int对应t1,float对应t2

类模板可以被特化

• 指定类模板的特定实现
• 部分参数类型必须显示指定
• 根据类型参数分开实现类模板
  

2.类模板的特化类型

2.1部分特化

用特定的规则约束类型参数,主要分三种情况
1） 第一种：类模板的两个参数类型相同

template<typename T> 
class Myclass<T ,T>{
};
或者
template<typename T> 
class Myclass<*T ,*T>{
};

2）有一个模板参数的类型为具体类型

template<typename T>
 class Myclass<T,double>{
};

3)两个模板参数的类型都是指针类型

template<typename T1,typename T2>
 class Myclass<*T1,*T2>{

};

2.2 完全特化-完全显示指定类型参数

59-1.cpp

#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 T>
class Test <T, T> //当Test类模板的两个类型参数完全相同时，调用这个模板,部分特化
{
public:
	void add(T a, T b)
	{
		cout << "add(T a, T b)" << endl;
		cout << a + b << endl;
	}
};


template//完全特化，不需要类型声明，如果T1，T2参数都为Void*的时候使用此实现
<>
class Test<void*, void*>
{
public:
	void add(void* a, void* b)
	{
		cout << "add(void* a, void* b)" << endl;
		cout <<"error on param"<< endl;
	}
};

template
<typename T1, typename T2>
class Test<T1*, T2*>
{
public:
	void add(T1* a, T2* b)
	{
		cout << "add(T1* a, T2* b)" << endl;
		cout << *a + *b << endl;
	}
};

int main()
{
	Test<int, float> t1;
    Test<int, int> t2;
	Test<void*, void*>t3;
	Test<int*, float*>t4;
	int a = 10;
	float b = 10.5;

	t1.add(1,2);
	t2.add(1,2);
	t3.add(NULL, NULL);
	t4.add(&a, &b);

	return 0;
}

结果：
void add(T1 a, T2 b)
3
add(T a, T b)
3
add(void* a, void* b)
error on param
add(T1* a, T2* b)
20.5

类模板的特化只是模板的分开实现，本质上只是同一个模板,特化类模板的使用方式是统一的，必须显示指定每一个类型参数

3. 问题：

类模板特化与重定义有什么区别？函数模板可以特化吗？

4.特化的深度分析

重定义和特化的不同之处：

• 重定义：一个类模板和一个新类(或者两个模板)使用的时候需要考虑如何选择的问题
• 特化：以统一的方式使用类模板和特化类，编译器自动选择特化类，函数模板只支持参数完全特化，不支持部分特化

59-2.cpp 特化的深入理解

template
<typename T>    //函数模板定义
bool Equal(T a,T b)
{
	return a == b;
}

template //函数模板完全特化
<>
bool Equal<void*>(void *a,void* b)
{
	return a == b
}

工程中的建议：当需要重载函数模板时，优先考虑模板特化，当模板无法满足时，再使用函数重载（两个都存在时，编译器默认选择全局的函数重载）

#include <iostream>
using namespace std;
//函数模板
template
<typename T>
bool equal(T a, T b)
{
    const double delta = 1e-10;
    double r = a - b;

    cout << "bool Equal(T a, T b) " << endl;
    return (-delta < r) && (r < delta);
}

//函数重载
bool equal(double a, double b)
{
    const double delta = 1e-10;
    double r = a - b;

    cout << "bool equal(double a,double b)" << endl;
    return (-delta < r) && (r < delta);
}

//函数模板完全特化
template
<>
bool equal<double>(double a, double b)
{
    cout << "bool equal<double>(double a, double b)" << endl;

    return a == b;
}


int main()
{
    double a = 12.2222;
    double b = 12.2222222;

    cout << equal(a, b) << endl;//两个的存在时，输出bool equal(double a, double b)
                                //全局重载函数不存在时，调用完全特化的函数模板
    cout << equal<>(a, b) << endl;//调用函数特化
    return 0;
}

5.小结

1.类模板可以定义任意多个不同类型的参数
2.类模板被部分特化和完全特化
3.特化的本质是模板的分开实现
4.函数模板只支持完全特化
5.工程中使用模板特化代替类(函数重定义)