STL学习--vector的学习

（一）：学习目标：
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 vec;
例如:
vector vec; //一个存放int类型的vector容器
vector vec; //一个存放float类型的vector

class CA{};
vector

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::const_iterator
第二个：vector::const_reverse_iterator
是前面讲的两种的只读形式。

6：vector带参数的构造
1）：带迭代器开始和结束的构造
例子：
//参数为迭代器的开始和结束
vector vecB(array,array+5);
vector vecC(vecA.begin(),vecA.end());

2）：vector vecD(3,9); //vector有3个元素，每个元素都是9

7：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,2

8：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中的数据结构以及其适用方法，不过还是需要多加练习。