C++ 容器详解

最新推荐文章于 2024-05-06 22:29:10 发布

专写bug的王同学

最新推荐文章于 2024-05-06 22:29:10 发布

阅读量4.9k

点赞数 11

分类专栏： C++ 文章标签： c++ 开发语言

本文链接：https://blog.csdn.net/wangcheng_BI/article/details/125405035

版权

C++ 专栏收录该内容

17 篇文章 2 订阅

订阅专栏

STL：

STL，即标准模板库，用着感觉和python差不多。

STL 六大组件：容器（序例式和关联式）算法（质变和非质变）迭代器仿函数适配器空间配置器。首先，我们来看以下Vector容器：

vector容器：

不同之处是数组是静态空间，而vector可以动态扩展。

迭代器：随机访问迭代器

vector.begin()指向第一个
vector.end()指向最后一个元素的后面一个
vector.rbegin()指向倒数第一个元素
vector.rend()指向第一个元素的前一个

容器嵌套:

vector<vector<int>>

构造：

vector<int>v1;
vector<int>v2(v1.begin(),v1.end())
vector<int>v3(10,100)

赋值：

直接等号赋值
vector.assign(10,100)
vector.assign(begin,end)

容量和大小：

empty()
capacity()
size()
resize(num)
resize(num,elem)elem为填充元素

插入和删除：

push_back() 尾部添加元素
pop_back()删除尾部元素
insert(迭代器pose，elem)
insert(迭代器pose，n,elem)插入n个
erase(迭代器pose)删除索引位置
erase（v.begin(),v.end()）区间删除
clear()清空

数据存取：

at(int dex)返回索引为idx的元素
operator[]返回索引为idx的元素，如v[idx]
front()返回容器中第一个数据元素
back()返回容器中最后一个数据元素

互换容器：

swap(v)

实际用途：收缩占用空间 vector<int>(v).swap(v),创建匿名对象进行互换，达到收缩空间的效果
预留空间：

reserve(len) 容器预留len个元素长度，不进行初始化，不可访问，而resize（）则被初始化为0

string容器：

string拼接函数：


string.append(str,n)截取前n个元素进行拼接
string.append(str,start,n)可以选择从第n个截取

string查找和替换：

string.find(str)返回查找子字符串中第一个元素的索引，没有返回-1
string.rfind(str)区别在于rfind从右往左查
string.replace(start,n,str)从start开始的n个字符替换为str

字符串比较（ASCII码值逐个比较）：

string.compare(str)大于返回1，等于返回0，小于返回-1

字符串存取：

string[i],string.at(i)可以修改或访问第i个元素

字符串插入和删除：

string.insert(n,str) str.erase(i,n)删除从i开始的n个字符

求子串操作：

string.substr(start,n)

deque容器：

构造：

deque<int>d1;
deque<int>d2(d1.begin(),d1.end());
deque<int>d3(10,100);
deque<int>d4(d3);

赋值操作：

deque<int>d2=d1;
deque<int>d3.assign(d1.begin(),d1.end());
deque<int>d4.assign(10,100)

大小操作：

deque.empty()
deque.size()
deque.resize(size)
deque.resize(size,elem)

插入和删除;

deque.push_back()尾插
deque.push_front()头插
deque.pop_back()尾删
deque.pop_front()头删
deque.erase(迭代器pose)
deque.insert(deque.begin(),elem)
deque.insert(deque.begin(),num,elem)
deque.insert(deque.begin(),d2.begin(),d2.end())
deque.erase（deque.begin(),deque.end()）
deque.clear()清空

数据存取：

at(int dex)返回索引为idx的元素
operator[]返回索引为idx的元素，如deque[idx]
front()返回容器中第一个数据元素
back()返回容器中最后一个数据元素

排序：

sort(iterator begin,iterator end)默认升序，对于支持随即访问迭代器的容器，都可以直接使用该算法进行排序

#include<iostream>
#include<vector>
#include<algorithm>
#include<deque>
using namespace std;
void printdeq(const deque<int >&d)
{
    for (deque<int>::const_iterator it=d.begin();it<d.end();it++)
    {
        cout<<*it<<" ";
    }
    cout<<endl;
}
void test()
{
    deque<int>d;
    d.push_back(1);
    d.push_back(3);
    d.push_back(2);
    sort(d.begin(),d.end());
    printdeq(d);

}


int main()
{
    test();
}

stack容器：(先进后出)

构造：

stack<int>s;

插入和删除：

stack.push()插入
stack.pop()删除
stack.empty()判断是否为空
stack.size()大小
s.top()栈顶元素

queue容器：（先进先出）

queue.push()插入
queue.pop()删除
queue.empty()判断是否为空
queue.size()大小
queue.front()队头元素
queue.back()队尾元素

list容器：

链表由一个个结点（数据域+指针域）构成，与数组相比可以快速添加或者和删除元素，但是遍历速度没有数组快，而且占用空间比数组要大。STL链表是双向循环链表。
迭代器属于双向迭代器，不支持随机访问，而且进行插入和删除操作时，原有迭代器不会失效。
构造函数：

list<int>l1;
list<int>l2(l1.begin(),l1.end())
list<int>l3(num,elem)
list<int>l4(l3)

赋值和交换：

list.assign(beg,end)
list.assign(num,elem)
=赋值，如l1=l2
l1.swap(l2)交换

大小操作：

list.size()
list.empty()
list.resize(size)
list.resize(size,elem)

插入和删除：

push_back(elem)尾插
pop_back()尾删
push_front(elem)头插
pop_front()头删
insert(pose,elem) pose(迭代器)处插入元素
insert(pose,n,elem)插入n个元素
insert(pose,beg,end)区间插入，从pose开始
clear()清空
erase(pose)删除pose处的元素
erase(beg,end)删除区间元素
remove(elem)移除elem元素

数据存取：

list.front()返回首元素
list.back()返回尾部元素
反转和排序：
list.reverse()反转
list.sort()排序,默认升序,若需要降序，则需要加仿函数

//list降序升序排列
#include <iostream>
#include <list>
using namespace std;

void printlist(list<int>&l)
{
    for(list<int>::iterator it=l.begin();it!=l.end();it++)
    {
        cout<<*it<<" ";
    }
    cout<<endl;
}
bool compare(int val1,int val2)
{
    return val1>val2;
}
void test()
{
    list<int>l;

        l.push_back(40);
        l.push_back(60);
        l.push_back(430);
        l.push_back(0);
        l.push_back(5);
        l.push_back(4);
        cout<<"排序前： "<<endl;
        printlist(l);
        l.sort();
        cout<<"升序排列： "<<endl;
        printlist(l);
        cout<<"降序排列： "<<endl;
        l.sort(compare);
        printlist(l);
}

int main()
{
    test();
    return 0;
}

//自定义类型排序
#include<iostream>
#include <list>
using namespace std;
class Person
{
    public:
    string name;
    int age;
    int height;
    Person(string na,int a,int b)
    {
        name=na;
        age=a;
        height=b;
    }
};
void setperson(list<Person>&l)
{
    Person p1("A",17,175);
    Person p2("B",18,172);
    Person p3("C",17,175);
    Person p4("D",18,168);
    Person p5("E",17,170);
    l.push_back(p1);
    l.push_back(p2);
    l.push_back(p3);
    l.push_back(p4);
    l.push_back(p5);
}
bool mycompare(Person p1,Person p2)
{
    if(p1.age==p2.age)
    {
        return p1.height<p2.height;
    }
    else
    return p1.age<p2.age;
}
void printperson(list<Person>l)
{
    for(list<Person>::iterator it=l.begin();it!=l.end();it++)
    {
        cout<<"姓名： "<<it->name<<"  age: "<<(*it).age<<"  height: "<<it->height<<endl;
    }
}
int main()
{

    list<Person>l;
    setperson(l);
    cout<<"排序前:"<<endl;
    printperson(l);
    l.sort(mycompare);
    cout<<"排序后:"<<endl;
    printperson(l);

    return 0;
}

set/multiset容器：

所有元素在插入时自动被排序，属于关联式容器，底层结构为二叉树
set与multiset区别：set不允许有重复元素，而multiset可以
构造和赋值：

set<int>s1
set<int>s2(s1)
=赋值
插入：只有insert方式
set.insert(elem)注意：若要是插入后元素是降序排列，则要使用仿函数作为排列规则

大小和交换：

set.size()
set.empty()
set.swap(l)

插入和删除：

set.insert(elem)
set.clear()
set.erase(pos)
set.erase(betg,end)
set.erase(elem)

查找和统计：

set.find(key)返回该元素的迭代器，若不存在，则fanhuiset.end()
set.count(key)

//利用仿函数指定创建时的排序规则
#include<iostream>
#include<string>
#include<set>
using namespace std;
class Person
{
public:
string name;
int age;
Person(string a,int b)
{
    this->name=a;
    this->age=b;
};
};

class mycompare
{
public:
   bool  operator()(const Person &p1,const Person &p2)
    {
        return p1.age>p2.age;
    }

};

void printperson(set<Person,mycompare>s)
{
    for(set<Person,mycompare>::iterator it=s.begin();it!=s.end();it++)
    {
        cout<<it->name<<"  "<<(*it).age<<endl;
    }
}

void setperson()
{
    Person p1("A",13);
    Person p2("B",12);
    Person p3("C",16);
    Person p4("D",10);
    set<Person,mycompare>s;
    cout<<"降序插入"<<endl;
    s.insert(p1);
    s.insert(p2);
    s.insert(p3);
    s.insert(p4);
    printperson(s);
}

int main()
{
    set<Person>p;
    setperson();
    return 0;
}

pair对组创建：

使用时不需要包含头文件
pair<type,type> p(val1,val2)
pair<type,type> p=make_pair(val1,val2)
获取：p.first p.second

map容器：

1.map中所有元素都是pair
2.pair中第一个元素时键值key，起到索引作用，第二个元素为实值value
3.所有元素会根据键值自动排序
4.属于关联式容器，底层用二叉树实现
map和multimap区别：
1.map允许有重复key值元素
2.multimap允许容器中有重复key值元素
构造和赋值：

map<int,int>m1;
map<int,int>m2(m1);
map<int,int>m3;m3=m2;

大小和交换：

map.size()
m.empty()
m.swap(m1)

插入和删除：

m.insert(elem)
m.clear()
m.erase(pose)
m.erase(beg,end)
m.erase(key)

查找和统计：

m.find(key)
m.count(key)

排序：可以利用仿函数指定排序规则

#include<iostream>
#include<string>
#include<map>
using namespace std;

class Mycompare
{
    public:
    bool operator()(int v1,int v2)
    {
        return v1>v2;
    }
};
void print1(map<int,int>&m)
{
    for(map<int,int>::iterator it=m.begin();it!=m.end();it++)
    {
        cout<<"key="<<it->first<<"value="<<it->second<<endl;
    }
    cout<<endl;
}
void test01()
{
    map<int,int>m;
    m.insert(make_pair(1,10));
    m.insert(make_pair(3,30));
    m.insert(make_pair(2,20));
    cout<<"升序"<<endl;
    print1(m);
}
void print2(map<int,int,Mycompare>&m)
{
    for(map<int,int,Mycompare>::iterator it=m.begin();it!=m.end();it++)
    {
        cout<<"key="<<it->first<<"value="<<it->second<<endl;
    }
    cout<<endl;
}
void test02()
{
    map<int,int,Mycompare>m1;
    m1.insert(make_pair(1,10));
    m1.insert(make_pair(3,30));
    m1.insert(make_pair(2,20));
    cout<<"降序"<<endl;
    print2(m1);
}
int main()
{
    test01();
    test02();
    return 0;
}

本文代码被本人不小心删除了大量例程，所以很多部分没有代码，若有不懂的小伙伴，欢迎讨论。