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

最新推荐文章于 2024-03-26 23:54:14 发布
最新推荐文章于 2024-03-26 23:54:14 发布
阅读量5.5k 收藏 5
点赞数
分类专栏： STL
本文为博主原创文章，未经博主允许不得转载。
本文链接：https://blog.csdn.net/Poisx/article/details/78108665
版权

一，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] = "巍盼盼";
chen_song_
关注
专栏目录
C++ STL教程（7）std::pair使用
二进制君
04-25 2223
其功能就是将一对值组合成为一个值，这一对值可以具有不同的数据类型（T1，T2），两个值可以分别用pair的两个公有函数first和second访问。比如在一个函数需要有两个返回值的时候，如果是相同的类型，可能会想到用数组，那么如果不是相同类型的，可能会想到用一个struct，但是为了使用方便可以直接使用c++自带的pair。std::pair是C++ STL的一个模板类，表示一对元素。另外，std::make_pair() 是一个非常方便的函数，可以通过两个参数直接创建一个std::pair对象。
STL源码分析学习笔记 之 第一章_STL简介和版本
qmw469702317的博客
01-09 338
第一章 STL概论与版本简介 1.1 STL概论 为了复用性的提升，为了建立数据结构和算法的一套标准，并且降低其间的耦合（coupling）关系以提升各自的独立性、弹性、交互操作性（interoperability），C++社群里面诞生了STL。 STL的价值 低层次 一套极具实用价值的零部件 一个整合的组织 高层次 以泛型思维（Generic Paradigm）为基础、系统化的、条理分...
List＜Pair＜Integer,Integer＞＞使用lambda排序
m0_71385141的博客
12-02 111
【代码】List＜Pair＜Integer,Integer＞＞使用lambda排序。
【STL】list容器的插入与删除
学吧 太深了
04-01 1425
【STL】list容器插入与删除 添加或插入新元素 list成员方法： push_front()：向 list 容器首个元素前添加新元素； push_back()：向 list 容器最后一个元素后添加新元素； emplace_front()：在容器首个元素前直接生成新的元素； emplace_back()：在容器最后一个元素后直接生成新的元素； emplace()：在容器的指定位置直接生成新的元素； insert()：在指定位置插入新元素； splice()：将其他 list 容器存储的多个元素添加到当前
STL中map, list, and pair的学习笔记
bigfacesafdasgfewgf
05-05 3093
STL中map, list, and pair的学习笔记
STL基础梳理 2019.1.17（Stack，queue，list，set, pair，仿函数，map ）
一直走，不要回头
01-17 227
Stack stack构造函数 stack&lt;T&gt; stkT;//stack采用模板类实现， stack对象的默认构造形式： stack(const stack &amp;stk);//拷贝构造函数 stack赋值操作 stack&amp; operator=(const stack &amp;stk);//重载等号操作符 stack数据存取...
STL之pair常见用法详解
lilian的博客
05-14 1345
摘自胡凡的《算法笔记》，仅作记录用！ 前言： pair可以将两个元素绑在一起作为一个合成元素， 如果要使用pair，则需要添加utility头文件，即#include<utility>，除此之外，还需要添加using namespace std;。注意，由于map的内部实现中涉及pair，就不需要额外再去添加utility头文件了。因此只需要添加头文件map即可 一、pair的定义 pair有两个参数，分别对应first和second的数据类型，它们可以是任意基本数据类型或容器，可以使用p
C++复习笔记--STL的list容器、set容器、pair对组和map容器
牵一只蜗牛去散步
03-21 543
需要强调的是，map容器对 key 进行排序，所以在构建 pair 对时，需要将自定义数据类型Person 置于 key 的位置，即而不是，才能使用 Person 进行排序！// 重新指定容器的长度为 num，若容器变长则以 elem 值填充，若容器变短则多余的元素会被删除。// 查找 key 是否存在，存在返回该 key 的迭代器，否则返回set.end();// 查找键值为 key 的元素，若存在返回该元素的迭代器，否则返回set.end();
vector list map pair stl 标准模板库 c++
01-15
在C++编程中，STL（Standard Template Library，标准模板库）是一个不可或缺的部分，它提供了高效、可重用和模块化的代码实现。STL的核心组件包括容器、迭代器、算法和函数对象。在这个主题中，我们将深入探讨四个...
STL学习，总结了map、vector、list的简单操作
10-18
STL（Standard Template Library，标准模板库）是C++编程语言中的一个重要组成部分，它提供了高效且灵活的数据结构和算法。本篇文章将详细讲解STL中的三个核心容器：map、vector和list，以及它们的基本操作。 首先...
[工具类]将list中元素,两两配对为Pair
VISION_SONG的博客
11-27 877
[工具类]将list中元素,两两配对为Pair
pair和list学习
blbq105的博客
08-05 281
/**********************pair学习************************/ #include<iostream> #include<vector> #include<string> using namespace std; int main(){ pair<string, int> p; ...
java list pair_java-使用流根据键值将List>合并到List >>
weixin_35148673的博客
02-16 485
我建议使用LinkedHashMap(它也支持条目的插入顺序)而不是List< Pair>>.使用它,您可以简单地使用Collectors.groupingBy()和Collectors.mapping()来实现：List> list = ...;Map> result = list.stream().collect(Collectors.groupingBy(Pai...
类模板带参数，list,pair
onlyou2030的博客
10-18 613
要求： Templates In this workshop, you design and code a class template and test it on two different classes. LEARNING OUTCOMES Upon successful completion of this workshop, you will have demonstrated
Java 排序Pair List的写法
大乐的博客
09-08 1213
List<Pair<Integer,Integer>> check = new ArrayList<>(); Collections.sort(check,(a,b)->a.getKey()-b.getKey());//lambda表达式，按左值从小到大排序 如果是数组， 要用Arrays.sort()
Pair＜＞与Map＜＞的区别？List＜Pair＜＞＞与Map＜＞的区别？
最新发布
m0_72647000的博客
03-26 249
Pair与Map的区别？List与Map的区别？
Mybatis 查询结果返回 Map、List＜Map＞、Pair
热门推荐
灵台方寸山斜月三星洞
02-16 3万+
com.jerry.mapper.TestMapper.java package com.jerry.mapper; import java.util.List; import java.util.Map; public interface TestMapper { /** * 查寻单个结果直接返回 Map&amp;amp;amp;lt;String, Object&amp;amp;amp;gt; * @param id * ..............
【STL】map中find的用法、map的insert插入：pair make_pair
zDavid_2018的博客
09-02 1746
用find函数来定位数据出现位置，它返回的一个迭代器，当数据出现时，它返回数据所在位置的迭代器，如果map中没有要查找的数据，它返回的迭代器等于end函数返回的迭代器，程序说明 #include <map> #include <string> #include <iostream> Using namespace std; Int main() { ...
pair stl 用法
09-02
pair是STL中的一个容器，用于将两个数据组合成一组数据。它在一些场景下非常有用，比如用作map的键值对插入，或者当一个函数需要返回两个数据时可以选择使用pair。你可以通过pair的first和second成员访问其中的元素。例如，如果有一个pair<int, int> p，你可以使用p.first访问第一个元素，使用p.second访问第二个元素。在C++中，pair的实现是一个结构体。以下是一个示例代码，展示了pair的使用方法： ``` #include <utility> #include <iostream> using namespace std; int main(){ pair<int, int> p<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* [c++ STL pair简单用法](https://blog.csdn.net/weixin_45063703/article/details/127915225)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_1"}}] [.reference_item style="max-width: 33.333333333333336%"] - *2* [C++ pair的基本用法总结整理](https://download.csdn.net/download/weixin_38621624/13709830)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_1"}}] [.reference_item style="max-width: 33.333333333333336%"] - *3* [STL之pair常见用法详解](https://blog.csdn.net/qq_41140987/article/details/106120500)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_1"}}] [.reference_item style="max-width: 33.333333333333336%"] [ .reference_list ]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值