C++ 常用 stl容器（vector向量,stack栈,queue队列,deque双向队列,map,set）

Posted 2023-04-02 Hang_ter

需要查询全面的stl可点击：

cplusplus（好久没更新了）

cppreference（标准，可能打不开）

cppreference（中文，好打开）

C++ Vectors

---

构造函数

语法:

vector();   vector( size_type num, const TYPE &val );   vector( const vector &from );   vector( input_iterator start, input_iterator end );

C++ Vectors可以使用以下任意一种参数方式构造:

• 无参数 - 构造一个空的vector,
• 数量(num)和值(val) - 构造一个初始放入num个值为val的元素的Vector
• vector(from) - 构造一个与vector from 相同的vector
• 迭代器(start)和迭代器(end) - 构造一个初始值为[start,end)区间元素的Vector(注:半开区间).

举例,下面这个实例构造了一个包含5个值为42的元素的Vector

vector<int> v1( 5, 42 );

---

运算符

语法:

v1 == v2   v1 != v2   v1 <= v2   v1 >= v2   v1 < v2   v1 > v2   v[]

C++ Vectors能够使用标准运算符: ==, !=, <=, >=, <, 和 >. 要访问vector中的某特定位置的元素可以使用 [] 操作符.

两个vectors被认为是相等的,如果:

1. 它们具有相同的容量
2. 所有相同位置的元素相等.

vectors之间大小的比较是按照词典规则.

相关内容: at().

---

assign函数

语法:

void assign( input_iterator start, input_iterator end );   void assign( size_type num, const TYPE &val );

assign() 函数要么将区间[start, end)的元素赋到当前vector,或者赋num个值为val的元素到vector中.这个函数将会清除掉为vector赋值以前的内容.

---

at函数

语法:

TYPE at( size_type loc );

at() 函数 返回当前Vector指定位置loc的元素的引用. at() 函数 比 [] 运算符更加安全, 因为它不会让你去访问到Vector内越界的元素. 例如, 考虑下面的代码:

vector<int> v( 5, 1 );

for( int i = 0; i < 10; i++ ) 

  cout << "Element " << i << " is " << v[i] << endl;

这段代码访问了vector末尾以后的元素,这将可能导致很危险的结果.以下的代码将更加安全:

vector<int> v( 5, 1 );

for( int i = 0; i < 10; i++ ) 

  cout << "Element " << i << " is " << v.at(i) << endl;

取代试图访问内存里非法值的作法,at() 函数能够辨别出访问是否越界并在越界的时候抛出一个异常.

相关内容: [] 操作符

---

back 函数

语法:

TYPE back();

back() 函数返回当前vector最末一个元素的引用.例如:

vector<int> v;

for( int i = 0; i < 5; i++ ) 

  v.push_back(i);

cout << "The first element is " << v.front() 

     << " and the last element is " << v.back() << endl;

这段代码产生如下结果:

The first element is 0 and the last element is 4

相关内容: front().

---

begin 函数

语法:

iterator begin();

begin()函数返回一个指向当前vector起始元素的迭代器.例如,下面这段使用了一个迭代器来显示出vector中的所有元素:

vector<int> v1( 5, 789 );

vector<int>::iterator it;

for( it = v1.begin(); it != v1.end(); it++ )

  cout << *it << endl;

相关内容: end().

---

capacity 函数

语法:

size_type capacity();

capacity() 函数 返回当前vector在重新进行内存分配以前所能容纳的元素数量.

---

clear 函数

语法:

void clear();

clear()函数删除当前vector中的所有元素.

---

empty 函数

语法:

bool empty();

如果当前vector没有容纳任何元素,则empty()函数返回true,否则返回false.例如,以下代码清空一个vector,并按照逆序显示所有的元素:

vector<int> v;

for( int i = 0; i < 5; i++ ) 

    v.push_back(i);

while( !v.empty() ) 

    cout << v.back() << endl;

    v.pop_back();

相关内容: size()

---

end 函数

语法:

iterator end();

end() 函数返回一个指向当前vector末尾元素的下一位置的迭代器.注意,如果你要访问末尾元素,需要先将此迭代器自减1.

相关内容: begin()

---

erase 函数

语法:

iterator erase( iterator loc );   iterator erase( iterator start, iterator end );

erase函数要么删作指定位置loc的元素,要么删除区间[start, end)的所有元素.返回值是指向删除的最后一个元素的下一位置的迭代器.例如:

// 创建一个vector,置入字母表的前十个字符

vector<char> alphaVector;

for( int i=0; i < 10; i++ )

    alphaVector.push_back( i + 65 );

int size = alphaVector.size();

vector<char>::iterator startIterator;

vector<char>::iterator tempIterator;

for( int i=0; i < size; i++ )

    tartIterator = alphaVector.begin();

    alphaVector.erase( startIterator );

    // Display the vector

    for( tempIterator = alphaVector.begin(); tempIterator != alphaVector.end(); tempIterator++ )

    cout << *tempIterator;

    cout << endl;

这段代码将会显示如下输出:

BCDEFGHIJ

CDEFGHIJ

DEFGHIJ

EFGHIJ

FGHIJ

GHIJ

HIJ

IJ

J

相关内容: pop_back().

---

front 函数

语法:

TYPE front();

front()函数返回当前vector起始元素的引用

相关内容: back().

---

get_allocator 函数

语法:

allocator_type get_allocator();

get_allocator() 函数返回当前vector的内存分配器.

---

insert 函数

语法:

iterator insert( iterator loc, const TYPE &val );   void insert( iterator loc, size_type num, const TYPE &val );   void insert( iterator loc, input_iterator start, input_iterator end );

insert() 函数有以下三种用法:

• 在指定位置loc前插入值为val的元素,返回指向这个元素的迭代器,
• 在指定位置loc前插入num个值为val的元素
• 在指定位置loc前插入区间[start, end)的所有元素 .

举例:

//创建一个vector,置入字母表的前十个字符

vector<char> alphaVector;

for( int i=0; i < 10; i++ )

  alphaVector.push_back( i + 65 );

//插入四个C到vector中

vector<char>::iterator theIterator = alphaVector.begin();

alphaVector.insert( theIterator, 4, 'C' );

//显示vector的内容

for( theIterator = alphaVector.begin(); theIterator != alphaVector.end(); theIterator++ )

  cout << *theIterator;

这段代码将显示:

CCCCABCDEFGHIJ

---

max_size 函数

语法:

size_type max_size();

max_size() 函数返回当前vector所能容纳元素数量的最大值(译注:包括可重新分配内存).

---

pop_back

语法:

void pop_back();

pop_back()函数删除当前vector最末的一个元素,例如:

vector<char> alphaVector;

for( int i=0; i < 10; i++ )

    alphaVector.push_back( i + 65 );

int size = alphaVector.size();

vector<char>::iterator theIterator;

for( int i=0; i < size; i++ ) 

  alphaVector.pop_back();

  for( theIterator = alphaVector.begin(); theIterator != alphaVector.end(); theIterator++ )

      cout << *theIterator;

  cout << endl;

这段代码将显示以下输出:

ABCDEFGHI

ABCDEFGH

ABCDEFG

ABCDEF

ABCDE

ABCD

ABC

AB

A

相关内容: erase().

---

push_back 函数

语法:

void push_back( const TYPE &val );

push_back()添加值为val的元素到当前vector末尾

---

rbegin 函数

语法:

reverse_iterator rbegin();

rbegin函数返回指向当前vector末尾的逆迭代器.(译注:实际指向末尾的下一位置,而其内容为末尾元素的值,详见逆代器相关内容)

---

rend 函数

语法:

reverse_iterator rend();

rend()函数返回指向当前vector起始位置的逆迭代器.

---

reserve 函数

语法:

void reserve( size_type size );

reserve()函数为当前vector预留至少共容纳size个元素的空间.(译注:实际空间可能大于size)

---

resize 函数

语法:

void resize( size_type size, TYPE val );

resize() 函数改变当前vector的大小为size,且对新创建的元素赋值val

---

size 函数

语法:

size_type size();

size() 函数返回当前vector所容纳元素的数目

相关内容: empty()

---

swap 函数

语法:

void swap( vector &from );

swap()函数交换当前vector与vector from的元素

C++ Stacks（堆栈）

---

操作

语法:

==   <=   >=   <   >   !=

所有的这些操作可以被用于堆栈. 相等指堆栈有相同的元素并有着相同的顺序。

---

empty

语法:

bool empty();

如当前堆栈为空，empty() 函数 返回 true 否则返回false.

---

pop

语法:

void pop();

pop() 函数移除堆栈中最顶层元素。

相关主题:
top(),

---

push

Syntax:

void push( const TYPE &val );

 push() 函数将 val 值压栈，使其成为栈顶的第一个元素。如:

    stack<int> s;

    for( int i=0; i < 10; i++ )

      s.push(i);

   

---

size

语法:

size_type size();

size() 函数返当前堆栈中的元素数目。如:

    stack<int> s;

    for( int i=0; i < 10; i++ )

      s.push(i);

    cout << "This stack has a size of " << s.size() << endl;

   

   

---

top

语法:

TYPE &top();

top() 函数返回对栈顶元素的引用. 举例,如下代码显现和清空一个堆栈。

    while( !s.empty() )

      cout << s.top() << " ";

      s.pop();

   

---

C++ Queue(队列)

---

back

语法:

TYPE &back();

back()返回一个引用，指向队列的最后一个元素。

---

empty

语法:

bool empty();

empty()函数返回真(true)如果队列为空，否则返回假(false)。

---

front

语法:

TYPE &front();

front()返回队列第一个元素的引用。

---

pop

语法:

void pop();

pop()函数删除队列的一个元素。

---

push

语法:

void push( const TYPE &val );

push()函数往队列中加入一个元素。

---

size

语法:

size_type size();

size()返回队列中元素的个数。

C++ deque(双向队列)

---

Constructors

语法:

deque();   deque( size_type size );   deque( size_type num, const TYPE &val );   deque( const deque &from );   deque( input_iterator start, input_iterator end );

C++ Deques能用以下方式创建:

• 无参，创建一个空双向队列
• size - 创建一个大小为size的双向队列
• num and val - 放置num个val的拷贝到队列中，
• from - 从from创建一个内容一样的双向队列
• start 和 end - 创建一个队列，保存从start到end的元素。

例如，下列代码创建并显示一个双向队列：

  // 创建一个双向队列，里面有10个1

  deque dq( 10, 1 );

  // 创建一个迭代器

  deque::iterator iter;

  // 显示这个双向队列

  for( iter = dq.begin(); iter != dq.end(); iter++ )

    cout << *iter << endl;

 

---

Operators

语法:

[]

你可以使用[]操作符访问双向队列中单个的元素。

---

assign

语法:

void assign( input_iterator start, input_iterator end);   void assign( Size num, const TYPE &val );

assign()函数用start和end指示的范围为双向队列赋值，或者设置成num个val。

---

at

语法:

reference at( size_type pos );

at()函数返回一个引用，指向双向队列中位置pos上的元素。

---

back

语法:

reference back();

back()返回一个引用，指向双向队列中最后一个元素。

---

begin

语法:

iterator begin();

begin()函数返回一个迭代器，指向双向队列的第一个元素。

---

clear

语法:

void clear();

clear()函数删除双向队列中所有元素。

---

empty

语法:

bool empty();

empty()返回真如果双向队列为空，否则返回假。

---

end

语法:

iterator end();

end()函数返回一个迭代器，指向双向队列的尾部。

---

erase

语法:

iterator erase( iterator pos );   iterator erase( iterator start, iterator end );

erase()函数删除pos位置上的元素，或者删除start和end之间的所有元素。返回值是一个iterator，指向被删除元素的后一个元素。

---

front

语法:

reference front();

front()函数返回一个引用，指向双向队列的头部。

---

get_allocator

语法:

allocator_type get_allocator();

get_allocator()函数返回双向队列的配置器。

---

insert

语法:

iterator insert( iterator pos, size_type num, const TYPE &val );   void insert( iterator pos, input_iterator start, input_iterator end );

insert()在pos前插入num个val值，或者插入从start到end范围内的元素到pos前面。

---

max_size

语法:

size_type max_size();

max_size()返回双向队列能容纳的最大元素个数。

---

pop_back

语法:

void pop_back();

pop_back()删除双向队列尾部的元素。

---

pop_front

语法:

void pop_front();

pop_front()删除双向队列头部的元素。

---

push_back

语法:

void push_back( const TYPE &val );

push_back()函数在双向队列的尾部加入一个值为val的元素。

---

push_front

语法:

void push_front( const TYPE &val );

push_front()函数在双向队列的头部加入一个值为val的元素。

---

rbegin

语法:

reverse_iterator rbegin();

rbegin()返回一个指向双向队列尾部的逆向迭代器。

---

rend

语法:

reverse_iterator rend();

rend()返回一个指向双向队列头部的逆向迭代器。

---

resize

语法:

void resize( size_type num, TYPE val );

resize()改变双向队列的大小为num，另加入的元素都被填充为val。

---

size

语法:

size_type size();

size()函数返回双向队列中的元素个数。

---

swap

语法:

void swap( deque &target );

swap()函数交换target和现双向队列中元素。

---

C++ deque(双向队列)

---

Constructors

语法:

deque();   deque( size_type size );   deque( size_type num, const TYPE &val );   deque( const deque &from );   deque( input_iterator start, input_iterator end );

C++ Deques能用以下方式创建:

• 无参，创建一个空双向队列
• size - 创建一个大小为size的双向队列
• num and val - 放置num个val的拷贝到队列中，
• from - 从from创建一个内容一样的双向队列
• start 和 end - 创建一个队列，保存从start到end的元素。

例如，下列代码创建并显示一个双向队列：

  // 创建一个双向队列，里面有10个1

  deque dq( 10, 1 );

  // 创建一个迭代器

  deque::iterator iter;

  // 显示这个双向队列

  for( iter = dq.begin(); iter != dq.end(); iter++ )

    cout << *iter << endl;

 

---

Operators

语法:

[]

你可以使用[]操作符访问双向队列中单个的元素。

---

assign

语法:

void assign( input_iterator start, input_iterator end);   void assign( Size num, const TYPE &val );

assign()函数用start和end指示的范围为双向队列赋值，或者设置成num个val。

---

at

语法:

reference at( size_type pos );

at()函数返回一个引用，指向双向队列中位置pos上的元素。

---

back

语法:

reference back();

back()返回一个引用，指向双向队列中最后一个元素。

---

begin

语法:

iterator begin();

begin()函数返回一个迭代器，指向双向队列的第一个元素。

---

clear

语法:

void clear();

clear()函数删除双向队列中所有元素。

---

empty

语法:

bool empty();

empty()返回真如果双向队列为空，否则返回假。

---

end

语法:

iterator end();

end()函数返回一个迭代器，指向双向队列的尾部。

---

erase

语法:

iterator erase( iterator pos );   iterator erase( iterator start, iterator end );

erase()函数删除pos位置上的元素，或者删除start和end之间的所有元素。返回值是一个iterator，指向被删除元素的后一个元素。

---

front

语法:

reference front();

front()函数返回一个引用，指向双向队列的头部。

---

get_allocator

语法:

allocator_type get_allocator();

get_allocator()函数返回双向队列的配置器。

---

insert

语法:

iterator insert( iterator pos, size_type num, const TYPE &val );   void insert( iterator pos, input_iterator start, input_iterator end );

insert()在pos前插入num个val值，或者插入从start到end范围内的元素到pos前面。

---

max_size

语法:

size_type max_size();

max_size()返回双向队列能容纳的最大元素个数。

---

pop_back

语法:

void pop_back();

pop_back()删除双向队列尾部的元素。

---

pop_front

语法:

void pop_front();

pop_front()删除双向队列头部的元素。

---

push_back

语法:

void push_back( const TYPE &val );

push_back()函数在双向队列的尾部加入一个值为val的元素。

---

push_front

语法:

void push_front( const TYPE &val );

push_front()函数在双向队列的头部加入一个值为val的元素。

---

rbegin

语法:

reverse_iterator rbegin();

rbegin()返回一个指向双向队列尾部的逆向迭代器。

---

rend

语法:

reverse_iterator rend();

rend()返回一个指向双向队列头部的逆向迭代器。

---

resize

语法:

void resize( size_type num, TYPE val );

resize()改变双向队列的大小为num，另加入的元素都被填充为val。

---

size

语法:

size_type size();

size()函数返回双向队列中的元素个数。

---

swap

语法:

void swap( deque &target );

swap()函数交换target和现双向队列中元素。

---

C++ Lists(链表)

---

赋值(assign)

语法:

void assign( input_iterator start, input_iterator end );   void assign( size_type num, const TYPE &val );

assign()函数以迭代器start和end指示的范围为list赋值或者为list赋值num个以val为值的元素。

相关主题:
insert(),

---

back

语法:

reference back();

back()函数返回一个引用，指向list的最后一个元素。

相关主题:
front(), pop_back(),

---

begin

语法:

iterator begin();

begin()函数返回一个迭代器，指向list的第一个元素。例如，

    // 创建一个元素类型是字符的链表

    list<char> charList;

    for( int i=0; i < 10; i++ )

      charList.push_front( i + 65 );

    // 显示这个链表

    list<char>::iterator theIterator;

    for( theIterator = charList.begin(); theIterator != charList.end(); theIterator++ )

      cout << *theIterator;

相关主题:
end(),

---

clear

语法:

void clear();

clear()函数删除list的所有元素。

---

empty

语法:

bool empty();

empty()函数返回真(true)如果链表为空，否则返回假。例如：

    list<int> the_list;

    for( int i = 0; i < 10; i++ )

      the_list.push_back( i );  

    while( !the_list.empty() ) 

      cout << the_list.front() << endl;

      the_list.pop_front();

---

end

语法:

iterator end();

end()函数返回一个迭代器，指向链表的末尾。

相关主题:
begin(),

---

erase

语法:

C++常用STL总结

vector

一个和数组类似的向量容器，除了数组的功能外还可以在尾部插入元素，可完全代替数组。vector是在堆中分配内存,元素连续存放，在插入和删除时会造成内存块的copy。

头文件

#include <vector>
#include<iostream>
using namespace std;

创建,初始值为0.

    vector<date type>v;
    vector<date type>v(number)；
    vector<date type>v(number,value)；
    //创建m*n的二维vector
    vector<vector <int> > ivec;
    ivec.resize(m,vector<int>(n));
    m*n的二维vector，所有元素为0
    vector<vector <int> > ivec(m ,vector<int>(n,0));    

赋值

    //直接赋值（和数组用法一样） 
    v[i]=value;
    //尾部扩张（每使用一次容器容量增加1）  
    v.push_back(date);

访问

    //下标访问同数组
    //迭代器访问
    vector<date type>::iterator it;  //定义迭代器变量
    for(it=v.begin():it!=end();it++)
    {
        cout<<*it<<endl;
    }

插入（自动扩张容器一个元素空间）

    v.insert(v.begin()+n,date);//在指针位置插入date
    v.insert(v.end()-n,date);//在指针位置插入date

删除

    v.clear(); //删除所有素同时元素空间置为o
    v.erase(v.begin()+n);//删除指针指向元素并删除这个元素空间
    v.erase(v.end()-n);//删除指针指向元素并删除这个元素空间
    v.erase(v.begin()+n,v.begin()+m);//（n<m）删除两个指针间所有元素及元素空间,当n>m时会进行内存块拷贝插入元素空间，使数据后移。
 

排序

#include<algorithm>//头文件
#include<iostream>
using namespace std;
//反向排序 
    reverse(v.begin()+n,v.begin()+m);//对两个指针间的数据进行反向排序
//快速排序
    sort(v.begin()+n,v.begin()+m);//对两个指针间的数据进行反向
//自定义比较排序
    bool cmp(...)
    {
        ...
    }
    sort(v.begin()+n,v.begin()+m，cmp);//对两个指针间的数据进行反向排序

其它

size();//返回元素个数
empty();//空返回1，否则返回0；
clear();//清空

string

#include<string.h>
#include<iostream>
using namespace std;
int main()
{
    sting s;//创建
    s.length();//返回长度

    s=s+‘a‘;//尾部添加
    s=s+"abc";

    string::iterator it=s.begin();
    s.erase(it+3);//删除第三个
    s.erase(it,it+4);//删除前4个
    s="";//清空

    s.empty();//空返回1，否则返回0
    s.replace(3,3,"××");//第3个开始的三个用××替换
    s.find(‘c‘);//查找 返回下标
    s.find("abc");//找不到返回4294967295
    s.compare("abcd");//比较 比对方大返回1 相等返回0 小返回-1
    reverse(s.begin(),s.end());//反向排序

    vector< string >v;//近似于二位数组的用法
    v.push_back("***");
    cout<<v[]<<end;
    cout<<v[][]<<endl;
    cout<<v[].length()<<endl;

    printf(s.c_str());//将sting用printf输出
}

set

自动过滤重复元素，检索效率高于vector，deque，list
multiset 允许重复

#include<set>
#include<iostream>
using namespace std;
int main()
{
    set<date type>s;//创建
    s.insert(date);//插入
    set<date type>::iterator it;
    for(it=s.begin();it!=s.end();it++)//中序遍历输出
    {
        cout<<*it<<" ";
    }
    
    set<int >::reverse_iterator rit;
    for(rit=s.rbegin();rit!=s.rend();rit++)//反向输出
    {
        cout<<*rit<<" ";
    }
    
    s.erase(date);//删除
   
    set<date type>::iterator it;
    it=s.find(3);//查找 找到返回地址 否则返回结尾地址
    if(it!=s.end());
    cout<<*it<<" ";
  
    struct cmp//非结构体从大到小输出
     {
        bool operator()(const int &a,const int &b)
        {
            if(a!=b)
                return a>b;
            else
                return a>b;
        }
     };
    set<int ,cmp>s;
    set<int,cmp >::iterator it;
   
    struct InFo//结构体从小到大排序
     {
        string name;
        int num;
        bool operator<(const InFo &a) const//<重载操作符
        {
            return a.num<num;
        }

    }；
}

map

映射容器，主键不能重复
multimap主键可重复

#include<map>
#include<iostream>
using namespace std;
int main()
{
    map<date1 type,date2 type>name;//创建

    name[date1]=date2;//按键值从小到大插入

    map<date1 type,date2 type>::iterator it;//遍历
    for(it=name.begin(); it!=name.end(); it++)
    {
        cout<<(*it).first<<" : "<<(*it).second<<endl;
    }

    m.erase();//删除

    map<date1 type,date2 type>::reverse_iterator rit;//反向遍历
    for(rit=name.rbegin(); rit!=name.rend(); rit++)
    {
        cout<<(*rit).first<<" : "<<(*rit).second<<endl;
    }

    map<date1 type,date2 type>::iterator it;//查找
    it=name.find(date1);
    if(it!=name.end())//找到了
    {
        ...
    }
    else//没找到
    {
        ...
    }
  
    struct cmp//非结构体自定义比较函数
        {
            bool operator ()(const date1 type &a,const date2 type &b)
            {
                if(a!=b)
                    return a>b;
                else
                    return a>b;
            }
        };
        map<date1 type,date2 type,cmp>name;//创建
        map<date1 type,date2 type,cmp>::iterator it;//遍历
        for(it=name.begin(); it!=name.end(); it++)
        {
            cout<<(*it).first<<" : "<<(*it).second<<endl;
        }

    struct sname//结构体自定义比价函数
    {
       date1 type xx;
       date2 type yy;
       bool operator < (const sname &a) const
       {
           return a.xx<xx;//按照xx从大到小排序
       }
    };
}

deque

双端队列

#include<deque>
#include<iostream>
using namespace std;
int main()
{
    deque<date type>name;//创建
    deque<date type>name(num);//创建大小为num的队列
    deque<date type>name（num，date）;//创建一个num个的队列并赋值为date
 
    name.push_back(date);//尾部插入 扩大元素个数
    name.push_front(date);//首部插入 覆盖首部的元素 不扩充
    name.insert(name.begin+s,date);//插入 覆盖员来的值 不扩充
    name.pop_front();//从头部删除
    name.pop_back();//从尾部删除
    name.erase(name.begin()+s);//从中间删除
    name.clear();//清空元素

    for（int i=0;i<name.size();i++）//遍历
    {
        cout<<name[i];
    }
    deque<date type>::iterator it;//遍历
    for(it=name.begin(); it!=name.end(); it++)
    {
         cout<<*it<<endl;
    }

    deque<date type>::reverse_iterator rit;//反向遍历
    for(rit=name.rbegin(); rit!=name.rend(); rit++)
    {
       cout<<*rit<<endl;
    }
}

list

#include<list>
#include<iostream>
using namespace std;
int main()
{
    list<date type>name;//创建
    list<sate type>name(num);//创建 大小为num的
    name.push_back(date);//后边插入并扩充
    name.push_front(date);//后边插入并扩充
    list<date type>::iterator it;
    it=name.begin();
    for(int i=0;i<n;i++)
    {
         it++;
    }
 
    name.insert(it,date);//中间插入并扩充
    name.pop_front();//删除首元素
    name.pop_back();//删除尾元素 
    name.remove(date);//删除值等于date的所有元素。

    list<date type>::iterator it;
    it=name.begin();
    {
        it++;
    }
    name.erase(it);//中间删除
    name.clear();//清空链表 

    list<date type>::iterator it;
    it=find(name.begin(),name.end(),date);//在指针范围内查找值为date的元素
    if(it!=name.end())//找到了

    for(it=name.begin();it!=name.end();it++)//遍历
    {
         cout<<*it;
    }

    list<date type>::reverse_iterator rit;//反向遍历
    for(it=name.rbegin();it!=name.rend();rit++)
    {
        cout<<*rit;
    }


    name.sort();//升序排序
    l.unique();//去重排序
}

bitset

#include<bitset>
#include<iostream>
using namespace std;
int main()
{

    bitset<num>name;//创建
    name[num]=0 or 1;//赋值
    name.set();//全设置为1
    name.reset();//全设置为0
    name.set(pos);//对pos位置赋值为1
    name.set(pos，0);//对pos位置赋值为0
    name.reset(pos);//对pos位置设置为0
    name.any();//存在1返回1 否则返回0
    name.none();//存在1返回0否则返回1
    name.count();//返回1的个数
    name.size();//返回二进制位数
    name.test(pos);//pos位置为1则返回1
    name.flip();//逐位取反
    name.flip(pos);//pos位置取反
    name.to_ulong();//返回一个unsigned long 值


    for(int i=b.size()-1;i>=0;i--)//循环输出
    {
        cout<<b[i];
    }
    cout<<name;//流输出
}

stack

#include<stack>
#include<iostream>
using namespace std;
int main()
{
    stack<daty type>name;//创建
    name.push(date);//入栈
    name.pop();//出栈
    name.top();//读取顶部值
    name.size();//返回栈大小
    name.empty();//判断是否为空

}

queue

#include<queue>
#include<iostream>
using namespace std;
int main()
{
    queue<date type>name;//创建
    name.push(date);//入队
    name.pop();//删除
    name.empty();//判断是否为空
    name.front();//返回队首的值
    name.back();//返回队尾的值
    name.size();//返回队列的大小
}

priority_queue();

name.top();//返回队首元素

struct sname//结构体时 < 定义优先级
{
  date1 type name1;
  date2 type name2;
  bool operator < (const sname &a) const
  {
      return a.name1<name1;//从小到大排列
  }
}

#include<vector>//（）定义优先级
struct cmp
{
  bool operator() (const int &a,const int &b)
  {
      return a>b;//从小到大
  }
}；
priority_queue<int ,vector<int>,cmp>name;

pair

pair<date1 type name1,date2 type name2>name[num];//创建
name.first=*;//赋值
name.second=*;
name[pos]=make_pair(date1, date2);//赋值  可两个同类型pair数直接赋值
cout << name.first << ‘ ‘ << name.second << endl;//输出