最近就看了一下stl的内容，总结一下，stl就是一个数据容器，所有的操作都是对容器里的数据进行操作
1，stack栈，这是一个先进后出的数据结构，它只有一个出口，只能对栈顶元素进行操作，就像一个教室只有一个门，先进去的人只能后出。
stack储存在
定义：stack<data_type> stack_name;
如：stack a,stackc;
操作：
empty() – 返回bool型，表示栈内是否为空 (s.empty() )
size() – 返回栈内元素个数 (s.size() )
top() – 返回栈顶元素值 (s.top() )
pop() – 移除栈顶元素(s.pop(); )
push(data_type a) – 向栈压入一个元素 a(s.push(a); )

#include<vector>
#include<iostream>
#include<string>
#include<stack>
using namespace std;
int main()
{
  stack<int> s;
  s.push(1);  //把1压栈存入数据
  s.push(2); //把2压栈存入数据
  s.push(3); //把3压栈存入数据
  int result = s.top(); // top();只输出第一个顶部数据，不弹栈
  int result2 = s.top();//result=result2
  s.pop(); // 把3弹出
  int result3 = s.top();//result3=2;
  cout << s.empty() << endl;//栈内元素不为空输出0
  int len= s.size();//len=2
  cout << result << " " << result2 << " " << result3 << endl; 
}
运行的结果就是  “
0
3 3 2”

2queue队列
queue是一种先进先出的数据结构，从底端加入元素，从顶端取出元素。就像一个教室有两个门一边进学生一边出学生，吧元素全部压入后对底端元素处理，
queue包含在头文件头文件:
定义：queue <data_type> queue_name;
如：queue q;
(1)push();就是从已有元素后面增加元素

queue<string>q;
q.push("coding");
cout<<q.front()<<endl;
输出结果是coding， push（）就是从已有元素后面增加元素，将其插入队列中。

(2)front();返回队列的第一个元素的值，这里只是返回，并没有把它剔除队列。

queue<string>q;
q.push("hahahaha");
q.push("abcd");
cout<<q.front()<<endl;
输出结果hahahaha

(3)back();返回队列的最后一个元素的值。

queue<string>q;
q.push("hahahaha");
q.push("abcd");
cout<<q.back()<<endl;
输出结果abcd

(4)pop();删除第一个元素

queue<string>q;
q.push("hahahaha");
q.push("bald man!");
pop();
cout<<q.front()<<endl;
如果没有pop()正常输出是hahahaha，现在有了pop()，即删除第一个元素，此时bald man!就是第一个元素了，最终输出

bald man!

(5)empty();判断队列是否为空，若为空则返回true。

queue<string>q;
cout<<q.empty()<<endl;
q.push("lalala");
cout<<q.empty()<<endl;
第一个为空，所以输出结果为1，第二个不为空，输出0。

(6)size();返回队列元素个数

queue<string>q;
q.push("hahahaha");
q.push("abcd");
cout<<q.size()<<endl;
输出12。

3，vector容器头文件为

vector<string> v1;         // 创建空容器，其对象类型为string类
vector<string> v2(10);     // 创建有10个具有初始值（即空串）的string类对象的容器
vector<string> v3(5, "hello"); // 创建有5个值为“hello”的string类对象的容器
vector<string> v4(v3.begin(), v3.end());  // v4是与v3相同的容器（完全复制）
bool empty() ;                    // 如果为容器为空，返回1；否则返回0
size_type max_size();            // 返回容器能容纳的最大元素个数
size_type size();                // 返回容器中元素个数  
size_type capacity();            // 容器能够存储的元素个数，有：capacity() >= size()  
void resize(size_type n, T x = T());   // 确保返回后，有：size() == n；如果之前size()<n，那么用元素x的值补全。
push_back(data_type a) 将元素a插入最尾端
  pop_back() 将最尾端元素删除
  v[i] 类似数组取第i个位置的元素(v[0] )
2. 对于二维vector的定义。
1)定义一个10个vector元素，并对每个vector符值1-10。
#include<stdio.h>
#include<vector>
#include <iostream>
using namespace std;
void main()
{
 int i = 0, j = 0;
//定义一个二维的动态数组，有10行，每一行是一个用一个vector存储这一行的数据。
所以每一行的长度是可以变化的。之所以用到vector<int>(0)是对vector初始化，否则不能对vector存入元素。
 vector<vector<int> > Array( 10, vector<int>(0) ); 
for( j = 0; j < 10; j++ )
 {
  for ( i = 0; i < 9; i++ )
  {
   Array[ j ].push_back( i );
  }
 }
 for( j = 0; j < 10; j++ )
 {
  for( i = 0; i < Array[ j ].size(); i++ )
  {
   cout << Array[ j ][ i ] << "  ";//输出每行的元素；
  }
  cout<< endl;
 }
}
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
int main(){
    vector<int> a;
    for (int i = 0; i < 5; ++i)
    {
        a.push_back(5 - i);//把每个元素压入数组
    }
    cout << "Size: " << a.size() << endl;//输出这个数组的长度
    a.pop_back();将最尾端元素删除即删除1
    a[0] = 1;
    cout << "Size: " << a.size() << endl;//长度为4
    for (int i = 0; i < (int)a.size(); ++i)
    {
        cout << a[i] << ", " << endl;
    }
    cout << endl;
    return 0;
}
输出结果是
Size: 5
Size: 4
1,
4,
3,
2,

4，sort排序头文件是
sort排序默认从小到大排序
sort(a,a+n)
如果想从大到小排序就要写一个函数

bool cmp(int a,int b)
{
   return a>b;
}
sort（a,a+n,cmp）

5，upper_bound 和 lower_bound

upper_bound(begin, end, value); 
返回>value的元素的第一个位置。
lower_bound(begin, end, value);
返回>=value的元素的第一个位置。
num[] = {1,2,2,3,4,5};
lower_bound(num, num + 6, 2)为num + 1
upper_bound(num, num + 6, 2)为num + 3
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
int main(){
    int a[10] = {1,3,5,2,4,6,7,5,2,5};
    sort(a, a + 10);
    for (int i = 0; i < 10; ++i)
    {
        cout<<a[i]<<“ “;
    }
    int *s, *e;
    s = lower_bound(a, a + 10, 5);//s=6
    e = upper_bound(a, a + 10, 5);//e=5
    cout<<s – a<<“\t”<< e - a;
    while(s != e)
    {
        cout<<*s++<<“ “;
    }
    return 0;
}
输出结果是
1 2 2 3 4 5 5 5 6 7 5   85 5 5

这两个函数就类似于二分查找吧
对于upper_bound来说，返回的是被查序列中第一个大于查找值的指针，也就是返回指向被查值>查找值的最小指针，
lower_bound则是返回的是被查序列中第一个大于等于查找值的指针，也就是返回指向被查值>=查找值的最小指针。
所以使用前要对序列进行排序。
目前经过查找资料和对课件的分析就总结了这些。