c++ STL常用容器使用(vector、deque、stack、queue、list、set、map等)

• 1、vector 使用
• 2、deque 双向数组
• 3、stack、queue（栈，队列）
• 4、list 链表
• 5、set/multiset
• 6、pair
• 7、map/multimap

动态数组，也叫可变数组，容器的空间是动态增长的，当空间不足时，申请更大一块空间，让后将原数据拷贝到新空间中，并释放原空间

1.1、初始化操作

    int arr[] = {1,3,2,5};
    // 1、方式一(初始化)
    vector v1;
    // 容器尾部插入数据
    v1.push_back(1);    
    v1.push_back(2);
    v1.pop_back(); // 尾部删除一个元素

    // 2、方式二(初始化)
    vector v2(arr,arr+sizeof(arr)/sizeof(arr[0]));

    // 3、方式三(初始化)
    vector v3(v2);

    // 4、方式4(初始化)
    vector v4(v2.begin(),v2.end());

    // 5、方式5(初始化) 给n个elem
    vector v5(10,2);  

1.2、赋值操作

    // 将v5区间的数据拷贝给v4
    v4.assign(v5.begin(),v5.end());
    
    // 将2个3拷贝复制给v4
    v4.assign(2,3);
    
    // 重载了=， 将v1的内容复制给v4
    v4 = v1;
    
    // 交换
    v4.swap(v3);

1.3、元素个数，容器容量

    cout<(v4).swap(v4);
    cout< 
1.4、取值操作
 
    cout< 
1.5、测试代码
 
#include 
#include 

using namespace std;

void print_vector(vector& p)
{   // 通过迭代器遍历容器
    for(vector::iterator it=p.begin(); it!= p.end(); it++)
    {
        cout<<*it<<" ";
    }
    cout< v1;
    // 容器尾部插入数据
    v1.push_back(1);    
    v1.push_back(2);
    v1.pop_back(); // 尾部删除一个元素
    print_vector(v1);

    // 2、方式二(初始化)
    vector v2(arr,arr+sizeof(arr)/sizeof(arr[0]));
    print_vector(v2);

    // 3、方式三(初始化)
    vector v3(v2);
    print_vector(v3);

    // 4、方式4(初始化)
    vector v4(v2.begin(),v2.end());
    print_vector(v4);

    // 5、方式5(初始化) 给n个elem
    vector v5(10,2);  
    print_vector(v5);

    // 赋值操作
    // 将v5区间的数据拷贝给v4
    v4.assign(v5.begin(),v5.end());
    print_vector(v4);
    
    // 将2个3拷贝复制给v4
    v4.assign(2,3);
    print_vector(v4);
    // 重载了=， 将v1的内容复制给v4
    v4 = v1;
    print_vector(v4);
    // 交换
    v4.swap(v3);
    print_vector(v4);

    cout<(v4).swap(v4);
    cout< 
2、deque 双向数组 
 
 
deque容器对比vector，支持插入删除容器头部元素，其他部分使用方法都一样，通过下面小案例使用
 
 
 
#include 
#include 
#include 
#include 
#include 
using namespace std;



class player
{
public:
    player()
    {

    }
    player(string name,int score):mName(name),mscore(score)
    {

    }
    string mName;
    int mscore;
};

void create_play(vector& v)
{
    string nameseed = "ABCDE";
    for(int i=0;i<5;i++)
    {
        player p;
        p.mName = "选手";
        p.mName += nameseed[i];
        p.mscore = 0;
        v.push_back(p);
    }
}


void fun2(int val)
{
    cout<& v)
{	// 遍历vector容器
    for(vector::iterator it=v.begin();it!=v.end();it++)
    {
        deque dScore;
        // 模拟进行打分
        for(int j=0;j<10;j++)
        {	// 随机生成分数
            int score = rand()%41+60;
            dScore.push_back(score);
        }
        // 对分数排序，默认从小到大
        sort(dScore.begin(),dScore.end());
        dScore.pop_front();
        dScore.pop_back();
        // 求平均分
        int totalScore = 0;
        for(deque::iterator dit=dScore.begin();dit!=dScore.end();dit++)
        {
            totalScore += (*dit);
        }
        int avg = totalScore/dScore.size();
        // 保存分数
        (*it).mscore = avg;

        // for_each(dScore.begin(),dScore.end(),fun2);
    }
}

// 排序规则
bool mycompare(player& p1,player& p2)
{
    return p1.mscore>p2.mscore;
}

void print_rank(vector& v)
{
    // 排序
    sort(v.begin(),v.end(),mycompare);    
    // 打印
    for(vector::iterator it = v.begin();it!=v.end();it++)
    {
        cout<<"姓名："<<(*it).mName<<"得分："<<(*it).mscore< vplist;
    create_play(vplist);
    set_Score(vplist);
    print_rank(vplist);

    return 0;
}
 
3、stack、queue（栈，队列） 
 
 
栈：先进后出
 队列：先进先出
 两者都，不提供迭代器，不能遍历，不支持随机存取
 
 
3.1、stack简单使用
 
#include 
    stack s1;
    s1.push(1);
    s1.push(3);
    s1.push(4);
    s1.push(2); // 插入元素
    cout< 
3.2、queue队列简单使用
 
    queue q1;
    q1.push(3);
    q1.push(1);
    q1.push(4);
    q1.push(2); // 插入元素
    cout< 
4、list 链表 
 
 
list是一个双向链表容器，插入删除元素比较高效
 list不可以随机存取元素，
 
 
    list l1;		// 其他初始化方式和上面容器用法一样
    l1.push_back(11);   // 尾部插入
    l1.push_front(12);  // 头尾插入
    l1.push_back(12);
    l1.push_back(31);
    l1.push_back(21);

    l1.pop_front(); // 头部删除
    l1.pop_back();  // 尾部删除

    l1.insert(l1.begin(),2,3);  // 开始位置插入2个3

    l1.erase(l1.begin());   // 删除第一个元素
    l1.remove(12);  // 删除元素中所有12 

    l1.size();  // 容器元素个数
    l1.empty(); // 容器是否为空
    l1.resize(10);  // 重新指定容器长度

    l1.reverse();   /// 反转链表
    l1.sort();	// 排序
  	// 链表自带排序
    // 因为 sort 只支持可随机访问的容器，list不可以
 
5、set/multiset 
 
 
set和multiset区别：
 set不支持插入重复值
 multiset支持
 
 
常用API：
clear()
erase(迭代器)
erase(迭代器区间)
erase(elem) // 删除容器中值为elem元素
find(key) // 查找key是否存在，返回改键的元素迭代器，若不存在，返回set.end()
count(key) // 统计key的元素个数
 
通过仿函数给自定义数据类型，排序
 
#include 
#include 
#include 

using namespace std;

// 自定义数据类型
class Person
{
public:
    Person(string name,int age,int height)
    {
        this->m_name = name;
        this->m_age = age;
        this->m_height = height;
    }
    string m_name;
    int m_age;
    int m_height;
};


class comparaPerson
{
public:
// 仿函数
    bool operator()(const Person&p1,const Person& p2)
    {
        return p1.m_age s1;
    Person p1("刘备",44,125);
    Person p2("关羽",123,155);
    Person p3("张飞",32,115);
    Person p4("赵云",12,175);
    Person p5("曹操",35,115);
    Person p6("小乔",35,145);
    Person p7("大乔",45,125);

    s1.insert(p1);
    s1.insert(p2);
    s1.insert(p3);
    s1.insert(p4);
    s1.insert(p5);
    s1.insert(p6);
    s1.insert(p7);

    for(set::iterator it=s1.begin();it!=s1.end();it++)
    {
        cout<m_name<<" "<m_age<<" "<m_height< 
6、pair 
pair p1;
p1 = make_pair("刘备",111); // 初始化
cout< 
7、map/multimap 
 
 
pair第一个键，第二个值
 所有元素都会根据元素的键值自动进行排序(从小到大)
 map和multimap区别：map不允许容器中有重复的key值，multimap允许
 
 
size()  // 元素个数
swap()  // 交换
erase(m.begin())    // 删除第一个元素
erase(m.begin(),m.end())    // 区间删除
erase(3)   // 按照key的方式删除 
find(key) // 按照key的方式操作，如果有返回元素迭代器，若不存在，返回end();
cout(key)   // 统计key元素个数
 
#include