STL标准模板库

Vector:

 写vector时候碰到这样一段代码：

    for(int j=0;j<v1.size();j++)
    { 
       printf("%d %d",j,v1[j]);
       printf("%d",v1.size());
       if(v1[j]==4)
       {
          v1.insert(v1.begin(),5); //在访问元素之前插入元素，那么元素的顺序整体就后面移动一位，那么一直访问到的都是4
          j++; 
       }
       getchar();
    }

Notice: 如果在遍历中需要插入删除元素，那么v1.size不能固定下来，否则会遗漏尾部的元素，在插入之后注意把迭代器或者索引向后移动一位，这样才会指向插入前那个元素的位置。在由迭代器加1指向下一个元素。

其实VECTOR本质上是一个可以容纳任何类型的动态数组。他用到了C++的动态数组，本质上是一个数组，存放在连续的区域，由此可以知道，中间插入或者删除会导致内存区域整块地移动，这样效率很低。所以Vector适合那些经常需要随机访问的类型，当让在末尾push_back，pop_back的速度是很快的，不会导致内存区域的整片移动。

// settest.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"

#include<set>
#include<algorithm>
#include<iterator>
using namespace std;

int _tmain(int argc, _TCHAR* argv[])
{
    /*set<int> myset;
    myset.insert(10);
    myset.insert(20);
    myset.insert(30);
    myset.insert(40);
    set<int>::iterator it = myset.begin();
    it=find(myset.begin(),myset.end(),30);
    
    //it=myset.find(30);
    //myset.insert(it,25);
    //it=myset.erase(it);
    //myset.erase(30);
    //printf("%d
",*it);*/

    set<int> s1;
    set<int> s2;
    set<int> result;
    set<int> diff;
    for(int i=1;i<=9;i++)
    {
        if(i%2==0)
            s2.insert(i);
        else
            s1.insert(i);
    }

    set_union(s1.begin(),s1.end(),s2.begin(),s2.end(),inserter(result,result.begin()));  //插入器
    printf("%d
",result.size());
    set_difference(result.begin(),result.end(),s1.begin(),s1.end(),inserter(diff,diff.begin()));
    printf("%d
",diff.size());
    printf("%d
",result.size());
    diff.clear();
    set_intersection(result.begin(),result.end(),s1.begin(),s1.end(),inserter(diff,diff.begin()));
    printf("%d
",diff.size());
    return 0;
}

Stack

栈的基本操作比较简单，push,pop,top，empty，size等函数。

empty() 堆栈为空则返回真 
pop() 移除栈顶元素 
push() 在栈顶增加元素 
size() 返回栈中元素数目 
top() 返回栈顶元素 

Sample:

#include<stack.h>

int main()
{
    stack<int> s;
    int j = 10;
    while(--j)
    {
       s.push(j);
    }
    while(!s.empty())
    {
       printf("%d
",s.top());
       s.pop();
    }
    getchar();
    return 0;
} 

 队列

 队列的操作和栈的操作差不多，都是类似的，多了一个back操作，队列front，栈的top操作。

back() 返回最后一个元素 
empty() 如果队列空则返回真 
front() 返回第一个元素 
pop() 删除第一个元素 
push() 在末尾加入一个元素 
size() 返回队列中元素的个数 

#include<queue.h>

int main()
{
    queue<int> q;
    q.push(1);
    q.push(2);
    printf("%d",q.front());
    printf("%d",q.back());
    while(!q.empty())
    {
       printf("%d
",q.front());
       q.pop();
    }
    getchar();
    return 0;
}

 列表

list，list和vector很像，但是不吃随机访问，没有[]运算符和at运算符

list可以push_back,push_front,insert元素，可以使用迭代器，也可以使用反向迭代器。还可以sort这个参数。指定sort参数

bool comp(const Student & s1,const Student & s2)
{
if(s1.score>s2.score)  true means it's right
return true;
return false;
}

#include<list.h>
#include<string.h>

struct Student
{
   char name[20];
   double score;
};

bool comp(const Student & s1,const Student & s2)
{
     if(s1.score>s2.score)
        return true;
    return false;
}
int main()
{
    list<Student> li;
    Student temp;
    //temp.name="laichunbin";
    strcpy(temp.name,"laichunbin");//constan char * 到 char * 需要strcpy来进行转换。赋值
    temp.score=89.33;
    li.push_back(temp);
    //temp.name="testuser";
    strcpy(temp.name,"testuser1");
    temp.score=95.33;
    li.push_front(temp);
    
    strcpy(temp.name,"testuser2");
    temp.score=85.3366;
    li.push_front(temp);
    
    strcpy(temp.name,"testuser2");
    temp.score=86.3366;
    li.push_front(temp);
    
//    for(int i=0;i<list.size();i++)
//    {
//       printf("%s %lf
",list[i].name,list[i].score);
//    }
    li.sort(comp);
    list<Student>::iterator it = li.begin(); //可以是反向迭代器reverse_iterator rbegin,rend参数
    
    for(;it!=li.end();it++)
    {
      printf("%s %lf
",it->name,it->score); //用指针操作运算符，而不是.
    }
    getchar();
    return 0;
}

 优先队列<priority_queue>

#include<stdio.h>
#include<queue>
#include<string>
using namespace std;

struct node
{
 int no;
 string name;
 bool operator<(const node & b) const  //结构体，注意函数后面加上const来说明这是一个常函数，才可以编译通过
 {
    if(no<b.no)
       return true;
    else if(name>b.name)
        return true;
    return false;
 }
};

int main()
{
    //priority_queue<int,vector<int>,greater<int> > q1;  整数
    priority_queue<node> q1;
//    q1.push(3);
//    q1.push(5);
//    q1.push(4);
//    q1.push(8);
//    while(!q1.empty())
//    {
//        printf("%d
",q1.top());
//        q1.pop();
//    }
     node a;
     a.no = 123;
     a.name="lai";
     q1.push(a);
     a.no=124;
     a.name="chun";
     q1.push(a);
     a.no=124;
     a.name="bin";
     q1.push(a);
     
     while(!q1.empty())
     {
         node tmp=q1.top();
        printf("%d %s
",tmp.no,tmp.name.c_str());
        q1.pop();
     }
     
    getchar();
    return 0;
} 

　　

集合操作，集合的又声明，在声明时候可以传入比较函数，也可以在结构体中使用比较符号。；insert操作，find，erase操作，迭代，反向迭代。set_union,set_difference,set_intersection;这个几个函数在algorothm库里面的。

#include<stdio.h>
#include<set>
#include<algorithm>
using namespace std;
struct mycmp{
bool operator()(const int & a,const int &b)
{
     if(a>b)
        return true;
     return false;
}
};
int main()
{
    
    set<int,mycmp> s;
    
    set<int>::iterator it;
    pair<set<int>::iterator,bool> ret;
    s.insert(8);
    s.insert(9);
    s.insert(5);
    s.insert(19);
    ret = s.insert(8);
    if(ret.second==false)
      printf("insert fail!"); 
    s.insert(25);
    
    it = s.begin();
    for(;it!=s.end();it++)
      printf("%d
",*it);
      
    it =s.find(8);
    s.erase(it);
    
    //sort(s.begin(),s.end());
    
    for(it=s.begin();it!=s.end();it++)
       printf("%d
",*it);
       
    getchar();
    return 0;
} 
=========================

set<int> s1;
set<int> s2;
set<int> output;
set<int>::iterator it;
s1.insert(1);
s1.insert(3);
s2.insert(3);
s2.insert(4);

set_union(s1.begin(),s1.end(),s2.begin(),s2.end(),inserter(output,output.begin()));
set_intersection()
set_difference();
set

for(it=output.begin();it!=output.end();it++)
printf("%d ",*it);