STL学习与示例

STL的本质就是:类模板,函数模板,运算符重载.说起来也是"多态"的表现形式,只不过具有高超的编程技巧和运用,能减少程序员的很多繁琐重复的工作,是一个优秀的"库".
       
        STL提供六大组件,彼此可以组合套用,共同组合成STL丰富多彩的编程应用:
1)容器(containers):各种数据结构(基本上就是集合类.容器是STL的最主要的标志,可以浅显得认为STL就是容器类的集合...)
 如:vector,list,deque,set,map,用来存放数据.

2)算法(algorithms):各种常用算法如:sort,search,copy,erase...

3)迭代器(iterator):
 扮演容器与算法直接的胶合剂,所所谓的"泛型指针".(我靠,本质还是从指针来的,只不过"变异"了..)
 共有5种类型,以及其他衍生变化:

4)仿函数(functors):行为类似函数,可作为算法的某种策略.(靠,其实就是类....)
 仿函数是一种重载了operator()的class或class template,一般函数指针可看作为狭义的仿函数.

5)配接器(adapters):(其实就是C#中的接口啦!!!)
 一种用来修饰容器(containers)或仿函数或迭代器接口的东西.

6)配置器(allocators):
 负责空间配置与管理.
 是一个实现了动态空间配置/空间管理/空间释放 的class template.

        OK.STL就是容器类+算法实现+迭代器+配接器+仿函数+配置器.

         容器通过配置器取得数据存储空间,算法通过迭代器存取容器内容,仿函数可以协助算法完成不同的策略变化,配接器可以修饰或套界仿函数.

以下着重说明STL的容器类以及一些基本的算法:
 
STL容器              所在头文件         特性
向量vector             <vector>     相当于多功能数组,但是最好不要对向量头进行添加或删除操作
双端队列deque     <deque>      基本与vector一样
表list                       <list>          对某一位置插入和删除操作花费小
队列queue             <queue>      插入只可以在尾部,删除/检索和修改只能在头部.先进先出(与stack相反)
堆栈stack              <stack>       后进先出
集合set                  <set>          每个节点包含一个元素,查找十分快速,不支持重复元素
多重集合multiset   <set>          和集合基本相同,支持重复元素
映射map                <map>       由键/值对组成的集合.(不能有重复键)
多重映射multimap <map>        可以有重复键.

        很多功能,可以用不同的容器来实现(这点很重要),但是要考虑实际的需要,选择合适的容器将大大提高程序性能.(对于新手来说,嘿嘿,能用就好,用顺手了,好好比较下不同情况下不同容器实现相同功能的效率撒...)

STL算法:主要头文件<algorithm>,<numeric>,<functional>.
<algorithm>:由模板函数组成.常用功能算法:比较,交换,查找,遍历,复制,修改,移除,反转,排序,合并等.
<numeric>:包含几个在序列上进行简单数学运算的模板函数,包括加法和乘法在序列上的一些操作.
<functional>:定义了一些模板类,即仿函数.      

STL迭代器:<iterator> (注意,可以把迭代器理解为指针,但是不能像指针一样使用迭代器...)
迭代器功能                               功能              头文件
输入迭代器(Input iterator)         向前读          istream
输出迭代器(Output iterator)      向前写          ostream,inserter
前向迭代器(Forward iterator)   向前读写
双向迭代器                               向前向后读写 list,set,vector,map,multimap,deque,queue
随即迭代器                               随即读写 vector,deque,array,string

1)构造STL容器对象
#include <iostream>
#include <vector>
using namespace std;

class VS
{
public:
 static void Show(vector<int> iv)
 {
  for(vector<int>::iterator iter=iv.begin(); iter!=iv.end(); iter++)
   cout<<*iter<<endl;
  cout<<"-----------------------------------------------"<<endl;
 }
};
void main()
{
 vector<int> iv1;   //构造方法1,默认构造无元素,使用push_back方法向容器中添加元素
 iv1.push_back(11);
 iv1.push_back(222);
 VS::Show(iv1);
 
 vector<int> iv2(2);   //构造方法2,构造2个int元素，默认初始值为0
 VS::Show(iv2);

 vector<int> iv3(3,1);  //构造方法3,构造3个int元素,指定初始值为1
 VS::Show(iv3);

 int a[] = {1,2,343,542,22}; //构造方法4,从数组中直接构造容器元素
 vector<int> iv4(a,a+5);
 VS::Show(iv4);

 vector<int> iv5(iv4);  //构造方法5,从其他容器中直接构造本容器元素
 VS::Show(iv5);

 vector<int>::iterator iter = iv4.begin(); //构造方法6,使用迭带器指针构造
 vector<int> iv6(iter+1,iter+3);
 VS::Show(iv6);

 cin.get();
}

//2)容器类的几种输出方式
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

template<typename T>
class print  //仔细看了,print其实是一个类,只不过重载了"()"运算符,使用起来就像函数,所以称为"仿函数"
{
public:
 void operator()(const T& elem)
 {
  cout<<elem<<"  ";
 }
};

void show(const vector<int>& iv)
{
 for (int i=0; i<iv.size(); i++)
  cout<<iv[i]<<"  ";
 cout<<endl<<"-----------------------------------"<<endl;
}
void display(const vector<int>& iv)
{
 for (vector<int>::const_iterator iter=iv.begin(); iter!=iv.end(); iter++)
  cout<<*iter<<"  ";
 cout<<endl<<"-----------------------------------"<<endl;
}

void main()
{
 int ia[6] = {0,1,2,3,4,5};
 vector<int> iv(ia,ia+6);
 show(iv);              //1)传统的索引输出
 display(iv);             //2)使用迭代器输出
 for_each(iv.begin(),iv.end(),print<int>());      //3)使用for_each方法输出,需要配合自定义输出函数
 cout<<endl<<"------------------------------------"<<endl;
 copy(iv.begin(), iv.end(), ostream_iterator<int>(cout, "  ")); //4)使用copy方法,调用系统输出函数
 cin.get();
}
//3)STL算法:演示sort排序和reverse翻转(这两个方法配合,就可以实现从小到大和从大到小排序了)
#include <iostream>
#include <algorithm>
using namespace std;

int main()
{
 int a[10] = {12,0,5,3,6,8,9,34,32,18};
 int b[5]  = {5,3,6,8,9};
 int d[15];
 sort(a,a+10);   //sort是从小到大排序,要实现从大到小排序,使用reverse方法翻转即可
 for (int i=0; i<10; i++)
 {
  cout<<" "<<a[i];
 }
 cout<<endl;

 sort(b,b+5); //b数组排序好,判断是否包含在排序好的a数组中

 if(includes(a,a+10,b,b+5))  //includes方法判断一个数组是否是另一个数组的子集合...
  cout<<"sorted b members are included in a.";//这里,可以发现数组a中也有"3,5,6,8,9"元素
 else
  cout<<"sorted a dosn't contain sorted b!";
 
 cout<<endl;

 reverse(a,a+10);  //翻转
 for (int i=0; i<10; i++)
 {
  cout<<" "<<a[i];
 }
 cout<<endl;

 cin.get();
 return 0;
}
//4)list列表容器,很常用的.
#include <iostream>
#include <list>    //使用list容器，必须加此头文件
using namespace std;

void main()
{
 list<int> pp;    //声明int元素类型的list容器对象

 for (int i=0; i<=9; i++)//后插
 {
  pp.push_back(i);//在当前list<int>容器的最后位置插上i的值
  pp.push_front(i*i); //在头部插入元素
  //insert()  在任意指定位置插入元素
 
 }
 //使用迭代器pi进行循环迭代输出pp容器中的所有元素
 copy(pp.begin(),pp.end(),ostream_iterator<int>(cout," "));
 cout<<endl<<"-----------------------------------------"<<endl;
 //按常规做法进行迭代输出是不行的，因为list容器是用链表构建的，不支持随即访问功能(这点要注意)
 //for (int i=0; i<pp.size(); i++)
 //{
 // cout<<pp[i]<<" ";
 //}
 cout<<pp.front()<<endl; //返回头元素
 cout<<pp.back()<<endl; //返回尾元素
 cout<<pp.size()<<endl; //显示此容器的所有元素个数

 pp.pop_back();   //移除最后一个元素
 pp.pop_front();   //移除最前一个元素
 copy(pp.begin(),pp.end(),ostream_iterator<int>(cout," "));
 cout<<endl<<"-----------------------------------------"<<endl;

 cout<< pp.max_size()<<endl; //此list容器所能申请的最大空间

 list<int>::iterator pi = pp.begin();  //声明迭代器pi，用来操纵list<int>容器对象
 pp.assign(2,3);    //assign是重新分配和构造的方法
 copy(pp.begin(),pp.end(),ostream_iterator<int>(cout," "));
 cout<<endl<<"-----------------------------------------"<<endl;

 list<int> ppp;
 cout<<ppp.empty()<<endl;  //empty方法判断容器是否为空
 cout<< pp.empty()<<endl;  //可以发现ppp.empty()返回1,即"true",而pp容器因为有2个元素,返回0,"false"非空

 cout<<pp.size()<<"clear方法清除前容器元素个数"<<endl;
 pp.clear();
 cout<<pp.size()<<"clear方法清除后容器元素个数"<<endl;

 cin.get();
}
//5)list进一步
#include <iostream>
#include <list>    //使用list容器，必须加此头文件
using namespace std;

template<class T>
void print_list(list<T>& p,string s)
{
 list<T>::iterator iter;
 for (iter=p.begin(); iter!=p.end(); iter++)
  cout<<*iter<<" ";
 for (string::iterator siter=s.begin(); siter!=s.end(); siter++)
  cout<<*siter;
 cout<<endl;
}

void main()
{
 int ia[] = {1,2,45,6,2,3};
 list<int> p1(ia,ia+6);  //使用数组初始化list<int>容器对象
 print_list(p1,"使用数组初始化list<int>容器对象");

 list<int> p2(p1);   //使用list<int>容器对象初始化list<int>容器对象
 p2.push_front(101);
 p2.push_back(1001);
 print_list(p2,"使用list<int>容器对象初始化list<int>容器对象");

 list<int> p3;
 p3 = p2;     //直接赋值
 print_list(p3,"直接赋值");  

 list<int>::iterator iter = p3.begin();
 p3.insert(iter,10000);  //使用迭代器在指定位置插入10000
 print_list(p3,"用迭代器在指定位置插入10000");
 iter++;      //这时iter指向p3容器的第2位置了
 p3.insert(iter,3,111); //在p3的第2个位置，连续插入3个111
 print_list(p3,"在p3的第2个位置，连续插入3个111");  

 p3.sort();    //进行排序,默认为升序
 print_list(p3,"进行排序,默认为升序");  
 p3.reverse();
 print_list(p3,"翻转容器元素,即sort和reverse方法相配合,达到了按降序排列的目的");  

 //list<int>容器p3与p2互相交换各自的值
 //常规做法,利用一个中间量来进行转换，这里直接使用一个swap就可以完成目的了
 p3.swap(p2);  
 print_list(p3,"与p2交换后的p3");
 print_list(p2,"与p3交换后的p2");

 p3.remove(1001);  //移除指定元素值为1001
 print_list(p3,"移除指定元素值为1001的p3");

 p3.erase(p3.begin(),p3.end());
 print_list(p3,"erase方法将指定区域内的容器元素全部清除");
 cout<<p3.size()<<endl;

 cin.get();
}