（一）：学习目标：
1：模板，包括函数模板和类模板
2：容器及其分类，以容器中的数据结构
3：容器vector和迭代器的具体用法
（二）：学习
1：函数模板
/**
* 学习模板函数
*/
int max(int a,int b){
return a > b?a:b;
}
float max(float a,float b){
return a > b?a:b;
}
char max(char a,char b){
return a > b?a : b;
}但是类型是比较多的，所以每一个类型都要写一个这样的函数的话，肯定是不行的。所以就有了模板函数。
下面就是模板函数：
/**
* 上面函数的模板函数
*/
template<typename T> //或者是 template<class T>
T max(T a,T b){
return a > b?a : b;
}T代表传入的类型
那么如何调用模板函数呢？
下面就是调用的代码：
注意：由于在STL里面max已经被定义了，所以在这里换一个名称
下面就是这个的定义和调用的过程
/*
* test.cpp
*
* Created on: 2015年4月15日
* Author: hongb_000
*/
#include <iostream>
using namespace std;
///**
// * 学习模板函数
// */
//int UIP_Max(int a,int b){
// return a > b?a:b;
//}
//
//float UIP_Max(float a,float b){
// return a > b?a:b;
//}
//
//char UIP_Max(char a,char b){
// return a > b?a : b;
//}
/**
* 上面函数的模板函数
*/
template<typename T> //或者是 template<class T>
T UIP_Max(T a,T b){
return a > b?a : b;
}
int main(void)
{
//注意这里的<int>是不能省略的，这里表示指定输入的类型
int m = UIP_Max<int>(10,20);
cout << m << endl;
char a = UIP_Max<char>('a','b');
cout << a << endl;
return 0;
}
模板函数会在运行过程中根据传入的类型进行替换相应的类型。所以这就实现了模板函数的功能。
2：模板类
现在假设我们有两个个类：
class IMax{
public:
IMax(int _a,int _b){
a = _a;
b = _b;
}
int GetMax(){
return a>b?a:b;
}
private:
int a;
int b;
};
class FMax{
public:
FMax(float _a,float _b){
a = _a;
b = _b;
}
int GetMax(){
return a>b?a:b;
}
private:
float a;
float b;
};这样遇到的问题和上面遇到的函数的问题是一样的，这样就引入了类模板。
下面我们写一下类模板
template <class T> //或者是 template<typename T>
class CMax{
public:
CMax(T _a,T _b){
a = _a;
b = _b;
}
T GetMax(){
return a > b ? a : b;
}
private:
T a;
T b;
};
与函数模板的定义差不多，凡是遇到类型的地方全部用T去替代。
那么如何使用这个类模板呢？下面我们来试一下：
//这样这个地方的<int>也是不能省略的，为了指定类型
CMax<int> cMax(10,20);
int p = cMax.GetMax();
cout << p << endl;类模板就是建立一个通用的类。
注意：
类模板可以定义多种类型：
template<typename T1,typename T2>3：容器的学习
容器是用来存放，管理一组元素的数据集合。
容器的数据结构如下面的图所示： 
容器有序列式的容器和关联式的容器。
序列式的容器有vector,deque,list
关联式的容器元素的位置取决于特定的排序的准则，
关联式的容器有set，multiset等
4：vector的学习
1）：vector的简介
vector是将元素置于一个动态的容器中进行管理，相当于一个动态的数组。
vector可以随机访问内部的数据。
vector尾部的插入和移除元素是比较简单的，但是在中间是比较复杂的。
2)：使用前的准备
#include <vector>
using namespace std;3):默认的构造
vector<T> vec;例如:
vector<int> vec; //一个存放int类型的vector容器
vector<float> vec; //一个存放float类型的vector
class CA{};
vector<CA*> vecCA; //用于存放CA的指针
vector<CA> vec; //用于存放CA的对象，不过这里一定要提供拷贝构造函数4)：vector末尾的添加和移除操作
vector:push_back(ele); //在容器尾部加入一个元素
vector:pop_back(); //移除容器中的最后一个元素
下面是一个测试的例子：
vector<int> vec;
vec.push_back(1);
//在vector后面插入一个元素
vec.push_back(2);
vec.push_back(3);
vec.push_back(4);
vec.push_back(5);
//将vector的最后一个元素移除
vec.pop_back();
for(size_t i = 0;i < vec.size();i++){
cout << vec.at(i) << " ";
}
输出结果为：
1 2 3 4
5)：vector数据的存取
vector获取元素有两种方式：
1：vec.at(i); //但是i越界的话，会跑出out_of_range一场
2：vec[i] //i越界的话没有异常抛出，直接报错
6)：对元素的修改
vector可以直接对某一个位置的元素进行修改。
例如:
vce.at(2) = 18;
下面是在刚刚那个例子的基础上进行调整:
//位置3的元素现在是3,我们把她改成19
vec.at(2) = 19;
for(size_t i = 0;i < vec.size();i++){
cout << vec.at(i) << " ";
}
cout << endl;则输出结果为:
1 2 3 4
1 2 19 4
7):访问vector的第一个值和最后一个值
int mFront = vec.front(); //第一个值
int mBack - vec.back(); //最后一个值
同时还可以使用这两个函数对其中的数值进行修改
例如：
我们想把第一个元素改成88：
vec.front() = 88; //这样就修改成功了
5：迭代器的学习
迭代器相当于一个指向，指向vector中的元素。
迭代器用来遍历容器中的内容，就像是一个指针，指向容器中的某一个位置。
1）：迭代器的类别
第一种：输入迭代器，只支持一次遍历
第二种：输出迭代器，只支持一遍输入
第三种：正向迭代器，可以进行多次读写
第四种：双向迭代器：就可以往前多次读写，又可以往后多次读写
第四种：随机访问迭代器：可以除了读写之外，还能读取和输入任意位置的内容
2）：双向迭代器支持的操作
it++,++it,it–,–it,*it,itA=itB,itA==itB,itA!=itB
其中list.set,multiset,map,multimap支持双向迭代器
3）：随机访问存储器
在双向迭代器的操作基础上添加加了随机功能
it+=i;it = i;it+i;it[i],itA
vector<int> vecA;
vecA.push_back(1);
vecA.push_back(3);
vecA.push_back(5);
vecA.push_back(7);
vecA.push_back(9);
//注意迭代器的写法
vector<int>::iterator it = vecA.begin();
cout << *it << endl; //输出应该就是第一个元素的值1
++it; //但是前++要比后++的效率高，因为前++返回的是一个引用，后++返回的是一个值
cout << *it << endl; //输出的应该就是3了
it += 3;
cout << *it << endl; //输出应该就是9了当it==vecA.end()的时候，就不能操作*it了，因为现在是最后一个元素的下一个位置
5）：使用迭代器进行vector的遍历
/**
* 使用迭代器进行vector的遍历
*/
vector<int>::iterator itA = vecA.begin();
for(;itA != vecA.end();itA++){
cout << *itA << " ";
}
6）：反向迭代器
/**
* 反向迭代器,逆序输出
*
* 其中的vec.rbegin()指向vector指向最后一个元素
* vec.rbegin()指向vector的第一个元素的上一个位置
*/
vector<int>::reverse_iterator rit = vecA.rbegin();
for(;rit != vecA.rend();rit++){
cout << *rit << " ";
}7）:还有两个
//第一个：vector<T>::const_iterator
//第二个：vector<T>::const_reverse_iterator是前面讲的两种的只读形式。
6：vector带参数的构造
1）：带迭代器开始和结束的构造
例子：
//参数为迭代器的开始和结束
vector<int> vecB(array,array+5);
vector<int> vecC(vecA.begin(),vecA.end());2）：
vector<int> vecD(3,9); //vector有3个元素，每个元素都是97：vector的赋值
1）：vector:assign(beg,end); //将(beg,end)区间的数据拷贝给本身。左闭右开
2）：vector:assign(n,ele); //n个ele元素
3）：vector:swap(vec); //将vec与本身进行互换
8：vector的大小
1）：vector:size(); //返回容器元素的个数，返回 size_z
2）：vector:empty(); //返回容器是否为空
3）：vector:resize(num); //重新指定容器的长度为num
4）：vector:resize(num,ele); //重新指定容器的长度，超过部分用ele填充，少的部分删除
例如：
vector<int> vecE;
vecE.push_back(1);
vecE.push_back(2);
vecE.push_back(3);
//当前vecE有元素1,2,3
vecE.resize(5); //现在的元素应该为1,2,3,0,0
vecE.resize(8,3); //现在的元素应该为1,2,3,0,0,3,3,3
vecE.resize(2); //现在的元素应该为1,28：vector的插入
1）：vector:insert(pos,ele); //在pos位置插入一个ele元素的拷贝，返回新数据的地址
2）：vector:insert(pos,n,ele); //在pos位置插入n个ele元素
3）：vector:insert(pos,beg,end): //在pos插入[beg,end)区间的元素
例子：
/**
* 插入测试
*/
vector<int> vecF;
vecF.push_back(1);
vecF.push_back(3);
vecF.push_back(5);
vecF.push_back(9);
vector<int> vecG;
vecG.push_back(2);
vecG.push_back(4);
vecG.push_back(6);
vecG.push_back(8);
vecF.insert(vecF.begin(),11); //现在vecF中的元素应该是11,1,3,5,7,9
vecF.insert(vecF.begin()+1,2,33); //现在vecF中的元素应该是 11,33,33,1,3,5,9
//执行之后的元素应该是2,4,6,8,11,33,33,1,3,5,9
vecF.insert(vecF.begin(),vecG.begin(),vecG.end());9：vector的元素删除
1）：vec.clear(); //移除容器中的所有的元素
2）：vec.erase(beg,end): //删除[beg,end)区间的元素
3）：vec.erase(pos); //删除pos位置的元素，返回下一个数据的位置
总结：
通过对小节的学习，基本上了解了vector中的数据结构以及其适用方法，不过还是需要多加练习。
