C++ 泛型基础

泛型的基本思想：
泛型编程（Generic Programming）是一种语言机制，通过它能够实现一个标准的容器库。
像类一样，泛型也是一种抽象数据类型，可是泛型不属于面向对象，它是面向对象的补充和发展。
在面向对象编程中，当算法与数据类型有关时，面向对象在对算法的抽象描写叙述方面存在一些缺陷。
比方对栈的描写叙述：
class stack
{

   push(參数类型)  //入栈算法

   pop(參数类型)   //出栈算法

}
假设把上面的伪代码看作算法描写叙述，没问题，由于算法与參数类型无关。可是假设把它写成可编译的源码，
就必须指明是什么类型，否则是无法通过编译的。使用重载来解决问题，即对N种不同的參数类型写N个
push和pop算法，这样是非常麻烦的，代码也无法通用。
若对上面的描写叙述进行改造例如以下：
首先指定一种通用类型T，不详细指明是哪一种类型。
class stack<參数模板 T>
{

   push(T)  //入栈算法

   pop(T)   //出栈算法

}

这里的參数模板T相当于一个占位符，当我们实例化类stack时，T会被详细的数据类型替换掉。
若定义对象S为statc类型，在实例化S时若我们将T指定int型则：
这时候类S就成为：
class S
{
    push(int)  //入栈算法
    pop(int)   //出栈算法
}
这时我能够称class stack<參数模板 T>是类的类，通过它能够生成详细參数类型不同的类。
泛型在C++中的应用：
泛型在C++中的主要实现为模板函数和模板类。
通常使用普通的函数实现一个与数据类型有关的算法是非常繁琐的，比方两个数的加法，要
考虑非常多类型：
int add(int a,int b) { return a+b; }
float add(float a,float b) { return  a+b; }
。。。。
尽管在C++中能够通过函数重载来解决问题，可是重复写同样算法的函数是比較辛苦的，
更重要的是函数重载是静态编译，执行时占用过多内存。
在此我们能够用C++的模板函数来表达通用型的函数，例如以下：
template<typename T> // 模板声明
T add(T a,T b) { return a+b; }  // 注意形參和返回值的类型
这时C++编译器会依据add函数的參数类型来生成一个与之相应的带详细參数类型的函数并
调用。
比如：
#include <iostream>
using namespace std;
template <typename T>
T add(T a,T b)  //注意形參和返回类型
{  
 return a+b;
}
void main()
{
    int num1, num2, sum;
    cin>>num1>>num2;
    sum=add(num1,num2); //用int匹配模版參数T，若sum,num1,num2类型不一致则无法匹配。
    cout<<sum;
}
函数模板的性质
1) 函数模板并非真正的函数，它仅仅是C++编译生成详细函数的一个模子。
2) 函数模板本身并不生成函数，实际生成的函数是替换函数模板的那个函数，比方上例中的add(sum1,sum2)，
    这样的替换是编译期就绑定的。
3) 函数模板不是仅仅编译一份满足多重须要，而是为每一种替换它的函数编译一份。
4) 函数模板不同意自己主动类型转换。
5) 函数模板不能够设置默认模板实參。比方template <typename T=0>不能够。
C++模版函数的语法
template  <typename 模版參数列表…>
函数返回类型 函数名（形參列表…）
上面两行能够合并成一行。
比如：
以下的几种写法是等效的而且class 和typename是能够互换的。
template  <typename T1, typename T2>
T1 fun(T1, T2, int )
{  //…..}
template  <typename T1,T2>  T1 fun(T1, T2, int )
{  //…..}
template  <class T1, class T2>
 T1 fun(T1, T2, int )
{  //…..}
template  <class T1,T2>  T1 fun(T1, T2, int )
{  //…..}
C++模版类的语法
template  <class 模版參数列表…>
class 类名
{ //类体}
成员的实现…
比如：
//类声明部分，有两个模板參数T1，T2
template  <class T1, class T2 >  
class A {
   private:
   int a;
  T1 b;  //成员变量也能够用模板參数
  public: 
  int fun1(T1 x, int y );
 T2 fun2(T1 x, T2 y);
}
//类实现部分
template  <class T1, class T2 >
int A<T1>:: fun1(T1 x, int y ){//实现…… }
 template  <class T1, class T2 >
T2 A<T1,T2>:: fun2(T1 x, T2 y) {//实现…… }
 //使用类A
 int main( ) {
 //定义对象a,并用int替换T1, float替换T2
   A<int, float>  a;
   //实例化a,调用a的属性和方法……
}
由上例能够看出, 类模板參数T1,T2对类的成员变量和成员函数均有效。
在C++编程中，当你要实现的一个类的某些成员函数和成员变量的算法
数据类型有关，能够考虑用类模板。C++版的数据结构算法大都用类模板实现。
类模板的性质
1) 类模板不是真正的类，它仅仅是C++编译器生成详细类的一个模子。
2) 类模板能够设置默认模板实參。
C++ STL简单介绍
　　STL（Standard Template Library，标准模板库)是C++对泛型编程思想的实现，最早是惠普实验室开发的。
在被引入C++之前该技术就已经存在了非常长的一段时间。后来STL成为ANSI/ISO C++标准的一部分。各个
C++厂商也有各自对应的模板库，这些库效率可能非常高，但可移植性不一定好。
　　STL广义上分为三类：algorithm（算法）、container（容器）和iterator（迭代器），差点儿全部的代码都採
用了模板类和模板函数的方式，这相比于传统的由函数和类组成的库来说提供了更好的代码重用机会。
　　在C++标准中，STL被组织为以下的13个头文件：<algorithm>、<deque>、<functional>、<iterator>、<vector>、
<list>、<map>、<memory>、<numeric>、<queue>、<set>、<stack> 和<utility>。
1) 算法（algorithm）
　　STL提供了大约100个实现算法的模版函数，算法部分主要由头文件<algorithm>，<numeric> 和<functional>组成。
　　<algorithm>是全部STL头文件里最大的一个，它是由一大堆模板函数组成的，当中经常使用到的功能范围涉及到比較、
交换、查找、遍历操作、复制、改动、移除、反转、排序、合并等等。
　　<numeric>体积非常小，仅仅包含一些简单数学运算的模板函数。
　　<functional>中则定义了一些模板类，用以声明函数对象。
2)  容器（container）（又称集合collection）
　　在实际的开发过程中，数据结构本身的重要性不会逊于操作于数据结构的算法的重要性，当程序中存在着对时间要
求非常高的部分时，数据结构的选择就显得更加重要。
　　通过设置一些模版类，STL容器对最经常使用的数据结构提供了支持，这些模板的參数同意指定容器中元素的数据类
型，能够将很多反复而乏味的工作简化。
例如以下表：

数据结构		实现头文件
向量(vector)	顺序性容器	<vector>
列表(list)	顺序性容器	<list>
双队列(deque)	顺序性容器	<deque>
集合(set)	关联容器	<set>
多重集合(multiset)	关联容器	<set>
栈(stack)	容器适配器	<stack>
队列(queue)	容器适配器	<queue>
优先队列(priority_queue)	容器适配器	<queue>
映射(map)	关联容器	<map>
多重映射(multimap)	关联容器	<map>

3)迭代器（iterator）
　　迭代器是一种同意程序猿检查容器内元素，并实现元素遍历的数据类型。C++标准库为每一种标准容器定义了一种迭代器类型。迭代器类型提供了比下标操作更一般化的方法：全部的标准库容器都定义了对应的迭代器类型，而仅仅有少数的容器（比方数组）支持下标操作。由于迭代器对全部的容器都适用，现代C++程序更倾向于使用迭代器而不是下标操作訪问容器元素。
　　迭代器从作用上来说是STL最主要的部分，迭代器在STL中用来将算法和容器联系起来，起着一种黏和剂的作用。差点儿STL提供的全部算法都是通过迭代器存取元素序列进行工作的，每个容器都定义了其本身所专有的迭代器，用以存取容器中的元素。
　　迭代器部分主要由头文件<utility>,<iterator> 和<memory>组成。<utility>是一个非常小的头文件，它包含了贯穿使用在STL中的几个模板的声明，<iterator>中提供了迭代器使用的很多方法， <memory>为容器中的元素分配存储空间，同一时候也为某些算法运行期间产生的暂时对象提供机制,<memory>中的主要部分是模板类allocator，它负责产生全部容器中的默认分配器。