stl_泛型的一些基本

一、泛型编程的一些基本 ：

　　1、泛型程序设计：

　　　　1.1、程序尽可能的通用。

　　　　1.2、将算法从数据结构中抽象出来，成为通用。

　　　　1.3、模板并不是单纯的函数，不能凭空的生成，是用来产生代码的代码，可以减少代码量。

　　　　1.4、template<> 中不要使用class， 使用typename；

　　　　1.5、模板编程与宏的区别：
　　　　　　　　宏是在编译时替换，而模板是在编译时生成。

　　　　1.6、通过函数模板写的模板函数，在实例化的时候生成了很多的代码。

　　　　　　template<typename T> //函数模板
　　　　　　const T& Max()　　//模板函数：在编译时实例化(非运时)
　　　　　　{}

　　　　1.7、模板在实例化时有两个步骤：

　　　　　　　　1、检查语法错误；

　　　　　　　　2、检查调用错误； 通过了语法检测之后， 生成对应的函数来进行调用检查。

　　　　1.8、模板的声明和定义不能放在不同的文件，包含也不行。 在声明的时候模板函数的名字已经改变了，
　　　　　　  所以找不到定义。

　　　　1.9、模板参数列表， 必须在函数参数列表中使用至少一次。类模板是无法推导的。 所以在类中是可以不用 T 类型。

　　　　1.10、模板函数是可以构成重载的，

　　　　　　　1.10.1、条件：
　　　　　　　　1、函数模板参数不同。
　　　　　　　　2、模板函数参数列表不同。

　　　　　　　1.10.2、模板函数还可以和普通函数构成重载。

　　　　　　　1.10.3、在函数模板中的重载是不能提升转换的。

　　　　1.11、

template<typename T, int num> : num 必须传递一个确定的值。 因为是编译时(非运行时)确定的。

　　　　1.12、特化：

　　　　　　1.12.1、函数模板的特化：

　　　　　　　　1、

template<> // 特殊化，当函数模板的 T = const char*; 的时候就不用生成了。
const char* Max(const char* lhs, const char* rhs)
{
return strcmp(lhs, rhs) > 0 ? lhs : rhs;
}

　　　　　　　　如果通篇没有使用到这个特化是不会生成的。

　　　　　　　　2、调用规则：首先调用非模板函数(提升转化) -> 特化 -> 模板函数所生成的函数。

　　　　　　1.12.2、类的特化：

　　　　　　　　1、类的特化(就是直接给定类型)：

template<>
class Array<int *>
{}

　　　　　　　　和函数的特化是一样的；

template<typename T> 特化：template<>
void Foo()    　　　　　　　void Foo<int>()
{}   　　　　　　　　　　　　{}

　　　　　　　　2、类的特化并不是继承， 两者没有任何关系， 是两个类。

　　　　1.12.3、模板类在编译的时候会生成，
　　　　　　　　如果对某个模板类进行了特化，那他就不会生成。所有的代码都是自己写的，
　　　　　　　　就相当于一个全新的类。

　　　　1.12.4、偏特化：

template<> 　　　　　　 // 就是对部分成员的特化。不是模板函数全特化。
Array<int *>::Array() // 特化的只是部分的方法，其余的代码编译器还是会
{}　　　　　　　　　　　 // 帮你生成。而进行了偏特化的代码就不会帮你生成了。

　　　　1.12.5、最大可能会对指针类型进行特化，因为不进行特化的话只会进行浅拷贝，这可能不符合需求。

　　1.13、模板类中的成员函数还可以做为模板函数。 另外模板类之间可以进行继承。

template<typename T>
classMyType
{
public:
template<typename X> //模板类中的函数模板
void Assign(X other) //模板类中的模板函数
{}
};
类外定义：
template<typename T> //注意顺序
template<typename X>
void classMyType<T>::Assign(X other)
{}