函数模板

泛型编程——不考虑具体数据类型的编程方式
C++中使用函数模版实现泛型编程，函数模板是一种可用不同类型进行调用的特殊函数，类型可被参数化，是C++重要的代码复用方式。

template <typename T>
void fun(T& a,T& b)
{
}

template关键字声明开始进行泛型编程
typename关键字声明泛指类型

函数模板可以自动类型推导调用，也可以具体类型显式调用。

int a=0,b=1;
fun(a,b);	//自动推导
float m=0,n=0;
fun<float>(m,n);	//显式调用

编译器从函数模板通过具体类型产生不同的函数
编译器对函数模板进行两次编译（对模板代码本身进行编译和对参数替换后的代码进行编译）
不允许隐式类型转换（自动推导类型时必须严格匹配，显式类型指定时能够进行隐式类型转换）

多参数函数模板（任意多个不同的类型参数）

template <typename T1，typename T2，typename T3>
T1 fun(T2& a, T3& b)
{
	return T1;
}

无法自动推导返回值类型，返回值必须显式指定
可以从左至右部分指定类型参数

int r1 = fun<int>(0.5, 0.5);
int r2 = fun<int,float>(1, 0.5);
int r3 = fun<int,float,double>(0.5, 0.5);

函数重载VS函数模板

函数模板可以像普通函数一样被重载
C++编译器优先考虑普通函数
函数模板能产生更好的匹配，则选择函数模板
空模板（<>）实参列表限定编译器只匹配函数模板

double r = fun<>(0.5, 0.5);

类模板

泛型编程的思想也可以应用于类，类模板是主要用于存储和组织数据元素的类，类中数据组织的方式和数据元素的具体类型无关，以相同的方式处理不同的类型。
C++类模版——只能显式指定具体类型，无法自动推导，使用具体类型定义对象。

template <typename T>
class class_name
{
public:
	T op(T& m,T& n);
}

class_name<int> op1;
class_name<int> op2;

声明的泛指类型T可以出现在类模板的任意地方
编译器从类模板通过具体类型产生不同的类
编译器在声明的地方对类模板代码本身进行编译
编译器在使用的地方对参数替换后的代码进行编译

PS：类模板工程应用

类模板必须在头文件中定义
类模板不能分开实现在不同的文件中
类模板外部定义的成员函数需加上模板<>声明

多参数类模板

template <typename T1, typename T2>
class class_name
{
public:
	void fun(T1 a,T2 b);
}
class_name<int,float> t;
t.fun(1,0.5);

特化

类模板可以被部分特化和完全特化，函数模板只支持完全特化。
部分特化：用特定规则约束类型参数
完全特化：完全显式指定类型参数
类模板被特化

指定类模板的特定实现
部分类型参数必须显式指定
根据类型参数分开实现类模板
特化是模版的分开实现，因此本质上是同一个类模板
特化类模板的使用方式是统一的，必须显式指定每一个类型的参数

template <typename T>
class class_name <T>
{
}
template <typename T1, typename T2>
class class_name <T1, T2>
{
}

重定义VS特化

重定义：一个类模板和一个新类（或两个类模板），使用的时候需要考虑如何选择

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

特化：以统一的方式使用类模板和特化类，编译器自动优先选择特化类。

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

PS：当需要重载函数模板时，优先考虑使用模板特化，当模板特化无法满足需求时，再使用函数重载。

异常处理

程序在运行过程中可能产生异常，异常（exception）是程序运行时可预料的执行分支，不同于bug（程序中的错误，不能被预料）。
异常

运行时产生除0情况
需要打开的外部文件不存在
数组访问越界
。。。

bug

使用野指针
堆空间使用结束后未释放
。。。
C++异常处理
try 语句试图处理正常代码逻辑
catch 语句处理异常情况
throw 语句抛出异常信息

double divide(double a,double b)
{
	const double delta =0.0000000000000000000001;
	double ret=0;
	if( (-delta<b) && (b<delta))
	{
		throw 0;
	}
	else
	{
		ret = a/b;
	}
	return ret;
}

try
{
	double r=divide(1,0);
}
catch(...)
{
	cout<<"divide zero ..."<<endl;
}