STL的学习之（一）list和pair对组的使用

一，list容器的使用

一些api的说明

1. 成员函数(构造函数)
2. 构造 list (公开成员函数)
3. (析构函数) 析构 list (公开成员函数)
4. operator= 赋值给容器 (公开成员函数)
5. assign 将值赋给容器 (公开成员函数)
6. get_allocator 返回相关的分配器 (公开成员函数) 元素访问
7. front 访问第一个元素 (公开成员函数) [编辑]
8. back 访问最后一个元素 (公开成员函数) [编辑]

9. 迭代器 begin cbegin 返回指向容器第一个元素的迭代器 (公开成员函数) [编辑] end cend
   返回指向容器尾端的迭代器 (公开成员函数) [编辑] rbegin crbegin

10. 返回一个指向容器最后一个元素的反向迭代器 (公开成员函数) [编辑] rend crend 返回一个指向容器前端的反向迭代器
    (公开成员函数) [编辑]

11. 容量 empty 检查容器是否为空 (公开成员函数) [编辑]
12. size 返回容纳的元素数 (公开成员函数) [编辑]
13. max_size 返回可容纳的最大元素数 (公开成员函数) [编辑]

修改器

1. clear 清除内容 (公开成员函数) [编辑]
2. insert 插入元素 (公开成员函数) [编辑]
3. emplace (C++11) 原位构造元素 (公开成员函数) [编辑]
4. erase 擦除元素 (公开成员函数) [编辑]
5. push_back 将元素添加到容器末尾 (公开成员函数) [编辑]
6. emplace_back (C++11) 在容器末尾就地构造元素 (公开成员函数) [编辑]
7. pop_back 移除末元素 (公开成员函数) [编辑]
8. push_front 插入元素到容器起始 (公开成员函数) [编辑]
9. emplace_front (C++11) 在容器头部就地构造元素 (公开成员函数) [编辑]
10. pop_front 移除首元素 (公开成员函数) [编辑]
11. resize 改变容器中可存储元素的个数 (公开成员函数) [编辑]
12. swap 交换内容 (公开成员函数) [编辑]

操作

1. merge 合并二个已排序列表 (公开成员函数) [编辑]
2. splice 从另一个list中移动元素 (公开成员函数) [编辑]
3. remove, remove_if 删除满足特定条件的元素 (公开成员函数) [编辑]
4. reverse 将该链表的所有元素的顺序反转 (公开成员函数) [编辑]
5. unique 删除连续的重复元素 (公开成员函数) [编辑]
6. sort 对元素进行排序 (公开成员函数) [编辑]

非成员函数
operator==
operator!=
operator<
operator<=
operator>
operator>=
根据字典顺序比较 list 中的值
(函数模板) [编辑]
std::swap(std::list)
特化 std::swap 算法
(函数模板) [编辑]
推导指引(C++17 起)

1，remove删除操作自定义的数据类型的要重写成员函数operator==函数

自定义数据class Person{public:    string m_name;    int m_age;    int m_height;    Person(string name, int age, int height)    {        this->m_name = name;        this->m_age = age;        this->m_height = height;    }     //重写==成员函数    bool operator==(const Person& p)    {        if ((this->m_age == p.m_age) && this->m_height == p.m_height && this->m_name == p.m_name)            return true;        return false;    }    //重写<函数    bool operator<(const Person& p)    {        if (this->m_age == p.m_age)            return (this->m_height < p.m_height);        return (this->m_age < p.m_age);    }    bool operator()(Person& p) const    {        if ((this->m_age == p.m_age) && this->m_height == p.m_height && this->m_name == p.m_name)            return true;        return false;    }};void printfPerson(const list<Person> & l){    for (list<Person>::const_iterator it = l.begin(); it != l.end(); it++)    {        cout << "姓名：" << (*it).m_name << ", 年龄：" << (*it).m_age << ", 身高：" << (*it).m_height << endl;    }}bool PersonComplate( Person p1,  Person p2){    if (p1.m_age == p2.m_age)        return (p1.m_height < p2.m_height);    return (p1.m_age < p2.m_age);}void test01(){    list<Person> l;    Person p1("陈丽", 22, 160);    Person p2("王蓉", 21, 158);    Person p3("王盼盼", 23, 165);    l.insert(l.begin(), p1);    l.insert(l.begin(), p2);    l.push_back(p3);    printfPerson(l);    //倒序    l.reverse();    cout << "-----------倒序-----------------" << endl;    printfPerson(l);    list<Person> l2;    l2.swap(l);    cout << "-----------l2---------------" << endl;    l2.push_front(Person("巍盼盼", 23, 150));    printfPerson(l2);    cout << "----------升序-------------" << endl;    //排序    l2.sort(PersonComplate);    printfPerson(l2);    cout << "-----------remove操作-----------" << endl;    //就是这步重写的    l2.remove(p2);    printfPerson(l2);    cout << "-------------splice-----------" << endl;    l2.splice(l.begin(), l2);    //Person p = l2.back();    //cout << p.m_name << endl;    printfPerson(l2);//  l2.assign(2, p3);    cout << "------------------------remove_if 重载（）运算符--------------" << endl;    l2.remove_if(p1);    printfPerson(l2);    cout << "------------------------merage 重载（）运算符--------------" << endl;    l2.push_back(p1);    l2.insert(l2.begin(), Person("aa", 3, 45));    l2.merge(l);    printfPerson(l2);}void printfint(const list<int> l){    for (list<int>::const_iterator it = l.begin(); it != l.end(); it++)        cout << (*it) << " ";    cout << endl;}void test02(){    list<int> l;    l.push_back(454);    l.push_back(44);    l.push_back(45);    l.push_back(4154);    printfint(l);    cout << "---------------remove_if ----------------" << endl;    //l.remove_if(44);    list<int> l2;    l2.push_back(8989);    l2.merge(l);    printfint(l);}int main(int argc, char *argv[]){    test01();    //test02();    system("pause");    return 0;}

为什么重写是因为数据类型没有指明看源码

    void remove(const _Ty& _Val)        {   // erase each element matching _Val        iterator _Val_it = end();        for (iterator _First = begin(); _First != end(); )           //重载operator==的操作            if (*_First == _Val)                if (_STD addressof(*_First) == _STD addressof(_Val))                    _Val_it = _First++;                else                    _First = erase(_First);            else                ++_First;        if (_Val_it != end())            erase(_Val_it);        }

splice操作

将一个列表中的元素移动到另外一个列表中.

#include <iostream>#include <list>std::ostream& operator<<(std::ostream& ostr, const std::list<int>& list){    for (auto &i : list) {        ostr << " " << i;    }    return ostr;}int main (){    std::list<int> list1 = { 1, 2, 3, 4, 5 };    std::list<int> list2 = { 10, 20, 30, 40, 50 };    auto it = list1.begin();    std::advance(it, 2);    list1.splice(it, list2);    std::cout << "list1: " << list1 << "\n";    std::cout << "list2: " << list2 << "\n";    list2.splice(list2.begin(), list1, it, list1.end());    std::cout << "list1: " << list1 << "\n";    std::cout << "list2: " << list2 << "\n";}

输出结果

list1:  1 2 10 20 30 40 50 3 4 5list2:list1:  1 2 10 20 30 40 50list2:  3 4 5

自定义类型的使用lower_bound，upper_bound ， equal_range函数的调用

自定义数据类型要对函数重载的操作要看源码

template<class _FwdIt,    class _Ty> inline    _FwdIt lower_bound(_FwdIt _First, _FwdIt _Last, const _Ty& _Val)    {   // find first element not before _Val, using operator<   告诉我们要重载运算符operator<的操作    return (_STD lower_bound(_First, _Last, _Val, less<>()));    }

具体的实现如下：

class Person{    //friend bool operator()(const Person& p1, const Person& p2) const;public:    string m_Name;    int m_age;    Person(string name, int age) :m_Name(name), m_age(age) {}    bool operator()(const Person& p) const;    bool operator<(const Person& p) const    {        return (this->m_age < p.m_age);    }};bool Person::operator()(const Person& p) const{    return (this->m_age == p.m_age);}void test01(){    set<Person> s;    s.insert(Person("陈丽", 22));    s.insert(Person("王盼盼", 23));    s.insert(Person("王蓉", 21));    s.insert(Person("巍盼盼", 20));    Person p("杨艳", 25);    s.insert(p);    set<Person>::iterator pos = lower_bound(s.begin(), s.end(), p);    pos = upper_bound(s.begin(), s.end(), p);    //对组的使用pair     pair<set<Person>::iterator, set<Person>::iterator> poi = equal_range(s.begin(), s.end(), p);    if (pos != s.end())    {        cout << "pos = " << pos->m_Name << endl;    }    /*Person p2("的李开复", 23);    p(p2);*/}int main(void){    test01();    system("pause");    return 0;}

map容器的操作

1. 成员函数 (构造函数)
2. 构造 map (公开成员函数) [编辑]
3. (析构函数) 析构 map (公开成员函数) [编辑]
4. operator= 赋值给容器 (公开成员函数) [编辑]
5. get_allocator 返回相关的分配器 (公开成员函数) [编辑]

元素的访问

1. at (C++11) 访问指定的元素，同时进行越界检查 (公开成员函数) [编辑] operator[] 访问指定的元素
   (公开成员函数) [编辑]

迭代器

1. begin cbegin 返回指向容器第一个元素的迭代器 (公开成员函数) [编辑] end cend

2. 返回指向容器尾端的迭代器 (公开成员函数) [编辑] rbegin crbegin

3. 返回一个指向容器最后一个元素的反向迭代器 (公开成员函数) [编辑] rend crend

返回一个指向容器前端的反向迭代器
(公开成员函数) [编辑]
容量

1. empty 检查容器是否为空 (公开成员函数) [编辑]
2. size 返回容纳的元素数 (公开成员函数) [编辑]
3. max_size 返回可容纳的最大元素数 (公开成员函数) [编辑]

修饰符

1. clear 清除内容 (公开成员函数) [编辑]
2. insert 插入元素或结点 (C++17 起) (公开成员函数) [编辑]
3. emplace (C++11) 原位构造元素 (公开成员函数) [编辑]
4. emplace_hint (C++11) 使用hint就地构造元素 (公开成员函数) [编辑]
5. erase 擦除元素 (公开成员函数) [编辑]
6. swap 交换内容 (公开成员函数) [编辑]

查找

1. count 返回匹配特定键的元素数量 (公开成员函数) [编辑]
2. find 寻找带有特定键的元素 (公开成员函数) [编辑]
3. equal_range 返回匹配特定键的元素范围 (公开成员函数) [编辑]
4. lower_bound 返回一个迭代器，指向第一个“不小于”给定值的元素 (公开成员函数) [编辑]
5. upper_bound 返回一个迭代器，指向第一个“大于”给定值的元素 (公开成员函数) [编辑]

观察器

1. key_comp 返回用于比较键的函数 (公开成员函数) [编辑]
2. value_comp 返回用于在value_type类型的对象中比较键的函数。 (公开成员函数) [编辑]

非成员函数
operator==
operator!=
operator<
operator<=
operator>
operator>=
根据字典顺序比较 map 中的值
(函数模板)

对组的定义pair

1. pair是key-value的形式
2. pair在和make_pair 在源码和pair对组是链接一起的

    // TEMPLATE FUNCTION make_pairtemplate<class _Ty1,    class _Ty2>    constexpr pair<typename _Unrefwrap<_Ty1>::type, typename _Unrefwrap<_Ty2>::type>        make_pair(_Ty1&& _Val1, _Ty2&& _Val2)    {   // return pair composed from arguments    using _Mypair = pair<typename _Unrefwrap<_Ty1>::type, typename _Unrefwrap<_Ty2>::type>;    return (_Mypair(_STD forward<_Ty1>(_Val1), _STD forward<_Ty2>(_Val2)));    }

在源码的中

template<class _Ty1,    class _Ty2>    struct pair    {   // store a pair of values    using first_type = _Ty1;    using second_type = _Ty2;

map容器的四中插入

    map<int, string> m;    //插入数据方式    m.insert(pair<int, string>(1, "陈丽"));    m.insert(make_pair<int, string>(2, "王蓉"));    m.insert(map<int, string>::value_type(3, "王盼盼"));    m[4] = "巍盼盼";