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 5
list2:
list1:  1 2 10 20 30 40 50
list2:  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_pair
template<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] = "巍盼盼";