c++ || STL关联式容器

已于 2022-09-08 19:05:25 修改
阅读量461 收藏
点赞数
分类专栏： 笔记 文章标签： c++ 算法 开发语言
于 2022-09-07 17:21:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LQEmptycity/article/details/126688329
版权
本文详细介绍了C++ STL中的关联式容器，包括pair类模板、map映射表、multimap多重映射表和set集合。关联式容器通过键值对存储元素，自动排序并提供高效的查找、访问、插入和删除操作。map和multimap允许键值对的键不可重复，而set和multiset则存储值相等的键值对，不允许重复值。底层实现通常采用红黑树。
摘要由CSDN通过智能技术生成

文章目录

关联式容器

  • 关联式容器与序列式容器不同的是，关联式容器在存储元素时还会为每个元素在配备一个键，整体以键值对的方式存储到容器中。
  • 关联式容器可以通过键值对< key,value >直接找到对应元素，无序遍历整个容器
  • 管理师容器在存储元素，默认会根据各元素键值的大小做升序排序
  • 关联式容器查找、访问、插入和删除指定元素的效率更高
关联式容器名称特点
map定义在 < map> 头文件中，使用该容器存储的数据，其各个元素的键必须是唯一的（即不能重复），该容器会根据各元素键的大小，默认进行升序排序（调用 std::less< T>）。
set定义在 < set> 头文件中，使用该容器存储的数据，各个元素键和值完全相同，且各个元素的值不能重复（保证了各元素键的唯一性）。该容器会自动根据各个元素的键（其实也就是元素值）的大小进行升序排序（调用 std::less< T>）。
multimap定义在 < map> 头文件中，和 map 容器唯一的不同在于，multimap 容器中存储元素的键可以重复。
multiset定义在 < set> 头文件中，和 set 容器唯一的不同在于，multiset 容器中存储元素的值可以重复（一旦值重复，则意味着键也是重复的）。

pair类模板

  • <“C语言教程”, “http://c.biancheng.net/c/”>
    第一个元素作为键（key），第二个元素作为值（value），由于**“键值对”并不是普通类型数据，因此STL标准库提供pair类模板**，专门用来将2个普通元素first和second（可以是c++基本数据类型，结构体，类自定义的类型）创建成一个新元素< first,second>.
  • pair类模板定义在< utility >头文件中
#1) 默认构造函数，即创建空的 pair 对象
pair();
#2) 直接使用 2 个元素初始化成 pair 对象
pair (const first_type& a, const second_type& b);
#3) 拷贝（复制）构造函数，即借助另一个 pair 对象，创建新的 pair 对象
template<class U, class V> pair (const pair<U,V>& pr);
#4) 移动构造函数
template<class U, class V> pair (pair<U,V>&& pr);
#5) 使用右值引用参数，创建 pair 对象
template<class U, class V> pair (U&& a, V&& b);

#include <iostream>
#include <utility>      // pair
#include <string>       // string
using namespace std;
int main() {
    // 调用构造函数 1，也就是默认构造函数
    pair <string, double> pair1;
    pair1.first = "数学教程";
    // 调用第 2 种构造函数
    pair <string, string> pair2("STL教程", "http://c.biancheng.net/stl/");
    // 调用拷贝构造函数
    pair <string, string> pair3(pair2);
    //调用移动构造函数
    pair <string, string> pair4(make_pair("C++教程", "http://c.biancheng.net/cplus/"));
    //调用了 make_pair() 函数，它也是 <utility> 头文件提供的，其功能是生成一个 pair 对象。
    // 因此，当我们将 make_pair()函数的返回值(是一个临时对象)作为参数传递给 pair()构造函数时，
    // 其调用的是移动构造函数，而不是拷贝构造函数。
    // 调用第 5 种构造函数
    pair <string, string> pair5(string("Python教程"), string("http://c.biancheng.net/python/"));

    cout << "pair1: " << pair1.first << " " << pair1.second << endl;
    cout << "pair2: " << pair2.first << " " << pair2.second << endl;
    cout << "pair3: " << pair3.first << " " << pair3.second << endl;
    cout << "pair4: " << pair4.first << " " << pair4.second << endl;
    cout << "pair5: " << pair5.first << " " << pair5.second << endl;
    //pair对象还可以进行比较 first相同则在比较second 都相同
    if (pair4 != pair2) {
        cout << "pair != pair2" << endl;
    }
    //pair2和pair3的key相同，value不同
    if (pair2 != pair3) {
        cout << "pair2 != pair3" << endl;
    }

    pair <string, int> pair8("pair", 10);
    pair <string, int> pair9("pair2", 20);
    //交换 pair8 和 pair9 的键值对
    pair8.swap(pair9);
    cout << "pair8: " << pair8.first << " " << pair8.second << endl;
    cout << "pair9: " << pair9.first << " " << pair9.second << endl;
    return 0;
}

map 映射表

  • map容器存储的都是pair对象，因此各个键值对的键和值可以是任意数据类型
    该容器存储的都是 pair<const K, T> 类型（其中 K 和 T 分别表示键和值的数据类型）的键值对元素。
  • 使用该容器存储的数据，其各个元素的键必须是唯一的且不能被修改（即不能重复），该容器会根据各元素键的大小，默认进行升序排序（调用 std::less< T>）
  • 手动指定map容器的排序规则，std::greater< T >
  • 底层是红黑树
成员方法功能
begin()返回指向容器中第一个（注意，是已排好序的第一个）键值对的双向迭代器。如果 map 容器用 const 限定，则该方法返回的是 const 类型的双向迭代器。
end()返回指向容器最后一个元素（注意，是已排好序的最后一个）所在位置后一个位置的双向迭代器，通常和 begin() 结合使用。如果 map 容器用 const 限定，则该方法返回的是 const 类型的双向迭代器。
rbegin()返回指向最后一个（注意，是已排好序的最后一个）元素的反向双向迭代器。如果 map 容器用 const 限定，则该方法返回的是 const 类型的反向双向迭代器。
rend()返回指向第一个（注意，是已排好序的第一个）元素所在位置前一个位置的反向双向迭代器。如果 map 容器用 const 限定，则该方法返回的是 const 类型的反向双向迭代器。
cbegin()和 begin() 功能相同，只不过在其基础上，增加了 const 属性，不能用于修改容器内存储的键值对。
cend()和 end() 功能相同，只不过在其基础上，增加了 const 属性，不能用于修改容器内存储的键值对。
crbegin()和 rbegin() 功能相同，只不过在其基础上，增加了 const 属性，不能用于修改容器内存储的键值对。
crend()和 rend() 功能相同，只不过在其基础上，增加了 const 属性，不能用于修改容器内存储的键值对。
find(key)在 map 容器中查找键为 key 的键值对，如果成功找到，则返回指向该键值对的双向迭代器；反之，则返回和 end() 方法一样的迭代器。另外，如果 map 容器用 const 限定，则该方法返回的是 const 类型的双向迭代器。
lower_bound(key)返回一个指向当前 map 容器中第一个大于或等于 key 的键值对的双向迭代器。如果 map 容器用 const 限定，则该方法返回的是 const 类型的双向迭代器。
upper_bound(key)返回一个指向当前 map 容器中第一个大于 key 的键值对的迭代器。如果 map 容器用 const 限定，则该方法返回的是 const 类型的双向迭代器。
equal_range(key)该方法返回一个 pair 对象（包含 2 个双向迭代器），其中 pair.first 和 lower_bound() 方法的返回值等价，pair.second 和 upper_bound() 方法的返回值等价。也就是说，该方法将返回一个范围，该范围中包含的键为 key 的键值对（map 容器键值对唯一，因此该范围最多包含一个键值对）。
empty()若容器为空，则返回 true；否则 false。
size()返回当前 map 容器中存有键值对的个数。
max_size()返回 map 容器所能容纳键值对的最大个数，不同的操作系统，其返回值亦不相同。
operator[]map容器重载了 [] 运算符，只要知道 map 容器中某个键值对的键的值，就可以向获取数组中元素那样，通过键直接获取对应的值。
at(key)找到 map 容器中 key 键对应的值，如果找不到，该函数会引发 out_of_range 异常。
insert()向 map 容器中插入键值对。
erase()删除 map 容器指定位置、指定键（key）值或者指定区域内的键值对。后续章节还会对该方法做重点讲解。
swap()交换 2 个 map 容器中存储的键值对，这意味着，操作的 2 个键值对的类型必须相同。
clear()清空 map 容器中所有的键值对，即使 map 容器的 size() 为 0。
emplace()在当前 map 容器中的指定位置处构造新键值对。其效果和插入键值对一样，但效率更高。
emplace_hint()在本质上和 emplace() 在 map 容器中构造新键值对的方式是一样的，不同之处在于，使用者必须为该方法提供一个指示键值对生成位置的迭代器，并作为该方法的第一个参数。
count(key)在当前 map 容器中，查找键为 key 的键值对的个数并返回。注意，由于 map 容器中各键值对的键的值是唯一的，因此该函数的返回值最大为 1。

map容器类模板 

template < 
    class Key,                                     // 指定键（key）的类型
    class T,                                       // 指定值（value）的类型
    class Compare = less<Key>,                     // 指定排序规则
    class Alloc = allocator<pair<const Key, T> >   // 指定分配器对象的类型
> class map;
//后两个参数有默认值

创建map容器 


int main()
{
    //创建空的map容器
    map<string, int> mymap; 
    
    //创建同时进行初始化
    map<string, int> mymap1{ {"sj",2} };
    map<string, int> mymap2{ make_pair("SJ",9) };

    //利用已创建好的容器在创建一个新的map容器
    map<string, int> mymap3(mymap1);
    //c++11标准中，增添了移动构造函数
    //当有临时的map对象作为参数，传递给要初始化的map容器时，会调用移动构造函数
    //创建一个会返回临时 map 对象的函数
    map<string, int> disMap(){
        map<string, int> tempMap{ {"C语言教程",10},{"STL教程",20} };
        return tempMap;
     }
    //调用 map 类模板的移动构造函数创建 newMap 容器
    map<string, int> newMap(disMap());

    //取已创建好的map容器指定区域内的键值对，初始化新的map容器
    map<string, int>myMap4{ {"C语言教程",10},{"STL教程",20} };
    map<string, int>newMap(++myMap4.begin(), myMap4.end());
    //键值对的键的大小按升序排列
    map<string, int, std::less<std::string> >myMap{ {"C语言教程",10},{"STL教程",20} };
    //键值对的键的大小按降序排列
    map<string, int, std::greater<std::string> >myMap{ {"C语言教程",10},{"STL教程",20} };
}

map的相应操作

在这里插入图片描述

int main()
{
    map<string, int> m{ {"SJ",9},{"EunHae",2},{"LHJ",1} ,{"LEETURK",1} };
    //会按照键的大小排序
 
    cout << "map容器的大小是： " << m.size() << endl;
    //从前到后遍历容器
    for (auto i = m.begin(); i != m.end(); i++)
    {        //第一个           最后一个的后一个
        cout << i->first << "  " << i->second << endl;
    }
    cout << endl;
    m.insert({ "LDH", 1 });
    m.emplace("YeSung",1 );   //更高效 
    for (auto i = m.rbegin(); i != m.rend(); i++)
    {        //最后一个          第一个的前一个
        cout << i->first << "  " << i->second << endl;
    }
    cout << endl;

    cout << "map容器是否为空： " << m.empty() << endl;
    cout << m.at("YeSung") << endl;  //输出键对应的值
    auto i = m.find("LDH");          //find找到键对应的键值对 返回相应的双向迭代器
    cout << i->first <<" " <<i->second << endl;
  
  //获取键对应的值
    int n = m["SJ"];
    cout << n << endl;
    return 0;
}
  • emplace和emplace_hint

emplace方法的返回值是一个pair对象，pair.first为一个迭代器，pair. second是一个bool类型变量

  1. 当该方法将键值对成功插入到 map 容器中时，其返回的迭代器指向该新插入的键值对，同时 bool 变量的值为 true；
  2. 当插入失败时，则表明 map 容器中存在具有相同键的键值对，此时返回的迭代器指向此具有相同键的键值对，同时 bool 变量的值为 false。
int main()
{
    //创建并初始化 map 容器
    std::map<string, string>mymap;
    //插入键值对
    pair<map<string, string>::iterator, bool> ret = mymap.emplace("STL教程", "http://c.biancheng.net/stl/");
    cout << "1、ret.iter = <{" << ret.first->first << ", " << ret.first->second << "}, " << ret.second << ">" << endl;
    //插入新键值对
    ret = mymap.emplace("C语言教程", "http://c.biancheng.net/c/");
    cout << "2、ret.iter = <{" << ret.first->first << ", " << ret.first->second << "}, " << ret.second << ">" << endl;
    //失败插入的样例
    ret = mymap.emplace("STL教程", "http://c.biancheng.net/java/");
    cout << "3、ret.iter = <{" << ret.first->first << ", " << ret.first->second << "}, " << ret.second << ">" << endl;
    return 0;
}

emplace_hint()

  1. 该方法不仅要传入创建键值对所需要的数据，还需要传入一个迭代器作为第一个参数，指明要插入的位置（新键值对键会插入到该迭代器指向的键值对的前面）；
  2. 该方法的返回值是一个迭代器，而不再是 pair 对象。当成功插入新键值对时，返回的迭代器指向新插入的键值对；反之，如果插入失败，则表明 map 容器中存有相同键的键值对，返回的迭代器就指向这个键值对。
int main()
{
    //创建并初始化 map 容器
    std::map<string, string>mymap;
    //指定在 map 容器插入键值对
    map<string, string>::iterator iter = mymap.emplace_hint(mymap.begin(),"STL教程", "http://c.biancheng.net/stl/");
    cout << iter->first << " " << iter->second << endl;
    iter = mymap.emplace_hint(mymap.begin(), "C语言教程", "http://c.biancheng.net/c/");
    cout << iter->first << " " << iter->second << endl;
    //插入失败样例
    iter = mymap.emplace_hint(mymap.begin(), "STL教程", "http://c.biancheng.net/java/");
    cout << iter->first << " " << iter->second << endl;
    return 0;
}

multimap 多重映射表

  • multimap容器具有和map相同的特性，multimap容器用于存储pair< const K, T>类型的键值对，各个键值对的键的值不能做修改，并且该容器也会自行根据键的大小对存储的所有键值对进行排序操作
  • 数据按key有序 底层是红黑树
  • multimap容器中可以同时存储多个键相同的键值对

multimap容器包含的成员方法与map容器相比，没有提供at()成员方法，也没有重载 [ ] 运算符
–>不能按照键值来获取指定键值对，因为有可能指定的键对应着多个键值对，而不是1个


int main()       //multimap容器相关操作
{
    //创建并初始化 multimap 容器
    multimap<char, int>mymultimap{ {'a',10},{'b',20},{'b',15}, {'c',30} };
    //输出 mymultimap 容器存储键值对的数量
    cout << mymultimap.size() << endl;
    //输出 mymultimap 容器中存储键为 'b' 的键值对的数量
    cout << mymultimap.count('b') << endl;
    for (auto iter = mymultimap.begin(); iter != mymultimap.end(); ++iter) {
        cout << iter->first << " " << iter->second << endl;
    }
    return 0;
}

int main()      //multimap容器的创建
{
    //默认构造函数 创建空的multimap容器
    multimap<string, string> mymultimap; 
    //创建同时进行初始化
    multimap<string, int> mymultimap{ {"C语言",2}, {"Python教程",3} };
    //借助 pair 类模板的构造函数来生成各个pair类型的键值对
    multimap<string, string>mymultimap{
    pair<string,string>{"C语言教程", "http://c.biancheng.net/c/"},
    pair<string,string>{ "Python教程", "http://c.biancheng.net/python/"},
    pair<string,string>{ "STL教程", "http://c.biancheng.net/stl/"}
    };
    //调用 make_pair() 函数，生成键值对元素
    //创建并初始化 multimap 容器
    multimap<string, string>mymultimap{
        make_pair("C语言教程", "http://c.biancheng.net/c/"),
        make_pair("Python教程", "http://c.biancheng.net/python/"),
        make_pair("STL教程", "http://c.biancheng.net/stl/")
    };
    multimap<string, string>newmultimap(mymultimap);
    multimap<char, int, std::greater<char>>mymultimap{ {'a',1},{'b',2} };
}

set 集合

特性

  • 不再以键值对的方式存储数据，因为 set 容器专门用于存储键和值相等的键值对，因此该容器中真正存储的是各个键值对的值（value）
  • 数据按key有序（自动排序）底层是红黑树（增删改查速度非常快）
  • set容器存储的各个元素的值必须各不相同
  • set容器没有强制对存储元素的类型做const修饰，因此set容器中存储的元素的值是可以修改的，但c++标准为了防止用户修改对此做了限制，正常情况下，用户无法修改set容器中的值

{<‘a’, 1>, <‘b’, 2>, <‘c’, 3>}
{<‘a’, ‘a’>, <‘b’, ‘b’>, <‘c’, ‘c’>}
set容器只能存储第2对键值对，无法存储第一组键值对

  • 使用set容器存储键值对时，只需要提供各键值对中的value值即可。
template < 
class T,                        // 键 key 和值 value 的类型
class Compare = less<T>,        // 指定 set 容器内部的排序规则
class Alloc = allocator<T>      // 指定分配器对象的类型
> class set;
  • set容器常用成员方法
成员方法功能
begin()返回指向容器中第一个（注意，是已排好序的第一个）元素的双向迭代器。如果 set 容器用 const 限定，则该方法返回的是 const 类型的双向迭代器。
end()返回指向容器最后一个元素（注意，是已排好序的最后一个）所在位置后一个位置的双向迭代器，通常和 begin() 结合使用。如果 set 容器用 const 限定，则该方法返回的是 const 类型的双向迭代器。
rbegin()返回指向最后一个（注意，是已排好序的最后一个）元素的反向双向迭代器。如果 set 容器用 const 限定，则该方法返回的是 const 类型的反向双向迭代器。
rend()返回指向第一个（注意，是已排好序的第一个）元素所在位置前一个位置的反向双向迭代器。如果 set 容器用 const 限定，则该方法返回的是 const 类型的反向双向迭代器。
cbegin()和 begin() 功能相同，只不过在其基础上，增加了 const 属性，不能用于修改容器内存储的元素值。
cend()和 end() 功能相同，只不过在其基础上，增加了 const 属性，不能用于修改容器内存储的元素值。
crbegin()和 rbegin() 功能相同，只不过在其基础上，增加了 const 属性，不能用于修改容器内存储的元素值。
crend()和 rend() 功能相同，只不过在其基础上，增加了 const 属性，不能用于修改容器内存储的元素值。
find(val)在 set 容器中查找值为 val 的元素，如果成功找到，则返回指向该元素的双向迭代器；反之，则返回和 end() 方法一样的迭代器。另外，如果 set 容器用 const 限定，则该方法返回的是 const 类型的双向迭代器。
lower_bound(val)返回一个指向当前 set 容器中第一个大于或等于 val 的元素的双向迭代器。如果 set 容器用 const 限定，则该方法返回的是 const 类型的双向迭代器。
upper_bound(val)返回一个指向当前 set 容器中第一个大于 val 的元素的迭代器。如果 set 容器用 const 限定，则该方法返回的是 const 类型的双向迭代器。
equal_range(val)该方法返回一个 pair 对象（包含 2 个双向迭代器），其中 pair.first 和 lower_bound() 方法的返回值等价，pair.second 和 upper_bound() 方法的返回值等价。也就是说，该方法将返回一个范围，该范围中包含的值为 val 的元素（set 容器中各个元素是唯一的，因此该范围最多包含一个元素）。
empty()若容器为空，则返回 true；否则 false。
size()返回当前 set 容器中存有元素的个数。
max_size()返回 set 容器所能容纳元素的最大个数，不同的操作系统，其返回值亦不相同。
insert()向 set 容器中插入元素。
erase()删除 set 容器中存储的元素。
swap()交换 2 个 set 容器中存储的所有元素。这意味着，操作的 2 个 set 容器的类型必须相同。
clear()清空 set 容器中所有的元素，即令 set 容器的 size() 为 0。
emplace()在当前 set 容器中的指定位置直接构造新元素。其效果和 insert() 一样，但效率更高。
emplace_hint()在本质上和 emplace() 在 set 容器中构造新元素的方式是一样的，不同之处在于，使用者必须为该方法提供一个指示新元素生成位置的迭代器，并作为该方法的第一个参数。
count(val)在当前 set 容器中，查找值为 val 的元素的个数，并返回。注意，由于 set 容器中各元素的值是唯一的，因此该函数的返回值最大为 1。
  • 创建set容器的方法
set<string> retSet()
{
    std::set<std::string> myset{ "http://c.biancheng.net/java/",
                            "http://c.biancheng.net/stl/",
                            "http://c.biancheng.net/python/" };
    return myset;
}
int main()
{
    set<string> myset;  //set默认升序排序 空set容器
    set<string> myset1{ "SJ","YeSung"};    //创建时初始化
    set<string> copyset(myset1);   //拷贝构造函数

    std::set<std::string> copyset(retSet());   //移动构造函数 创建新容器的同时利用临时的set容器对其进行初始化

    std::set<std::string> myset{ "http://c.biancheng.net/java/",
                    "http://c.biancheng.net/stl/",
                    "http://c.biancheng.net/python/" };
    std::set<std::string> copyset(++myset.begin(), myset.end());//set容器中部分元素进行初始化

    std::set<std::string, std::greater<string> > myset{
    "http://c.biancheng.net/java/",
    "http://c.biancheng.net/stl/",
    "http://c.biancheng.net/python/" };  
     //修改排序方式为降序排序

}
  • set相关操作
int main()
{
    set<string> myset{ "SJ","YeSung" ,"LeeTurk","LDH","LDH"};    //创建时初始化
    for (auto i = myset.begin(); i != myset.end(); i++)
    {
        cout << *i << " ";
    }
    cout << endl;
    for (auto i = myset.rbegin(); i != myset.rend(); i++)    //逆向
    {
        cout << *i << " ";
    }
    cout << endl;
    auto my = myset.find("YeSung");  //返回成功找到的双向迭代器
    cout << *my << endl;
    auto upper = myset.upper_bound("LDH");   //返回第一个大于val的双向迭代器
    cout << *upper << endl;
    auto lower = myset.lower_bound("LeeTurk");   //返回第一个大于或等于val的双向迭代器
    cout << *lower << endl;
    cout << myset.max_size() << endl;   //能容纳元素最大个数
    myset.insert("LHJ");                ///插入
    for (auto i = myset.begin(); i != myset.end(); i++)
    {
        cout << *i << " ";
    }
    cout << endl;
    cout << myset.count("LDH") << endl;     //val元素的个数 最大为1
        //向 myset 容器中添加元素
    pair<set<string, string>::iterator, bool> ret = myset.emplace("http://c.biancheng.net/stl/");
    cout << "myset size = " << myset.size() << endl;
    cout << "ret.iter = <" << *(ret.first) << ", " << ret.second << ">" << endl;
    return 0;
}
  • erase()和 clear()
//删除 set 容器中值为 val 的元素
//返回成功删除的元素个数
size_type erase (const value_type& val);
//后两种返回都是迭代器，指向set容器删除元素之后的第一个元素
//删除是最后一个元素 则返回最后一个元素的之后的位置，相当于end()方法返回的迭代器
//删除 position 迭代器指向的元素
iterator  erase (const_iterator position);
//删除 [first,last) 区间内的所有元素
iterator  erase (const_iterator first, const_iterator last);

void clear(); //删除容器中所有元素

int main()
{
    //创建并初始化 set 容器
    std::set<int>myset{ 1,2,3,4,5 };
    cout << "myset size = " << myset.size() << endl;

    //1) 调用第一种格式的 erase() 方法
    int num = myset.erase(2); //删除元素 2，myset={1,3,4,5}
    cout << "1、myset size = " << myset.size() << endl;
    cout << "num = " << num << endl;
    //2) 调用第二种格式的 erase() 方法
    set<int>::iterator iter = myset.erase(myset.begin()); //删除元素 1，myset={3,4,5}
    cout << "2、myset size = " << myset.size() << endl;
    cout << "iter->" << *iter << endl; //3
    //3) 调用第三种格式的 erase() 方法
    set<int>::iterator iter2 = myset.erase(myset.begin(), --myset.end());//删除元素 3,4，myset={5}
    cout << "3、myset size = " << myset.size() << endl;
    cout << "iter2->" << *iter2 << endl;//5


    myset.clear(); //删除所有元素
    return 0;
}

multiset 多重集合

特性

  • 不再以键值对的方式存储数据，multiset 容器专门用于存储键和值相等的键值对，因此该容器中真正存储的是各个键值对的值（value）；
  • multiset 容器在存储数据时，会根据各元素值的大小对存储的元素进行排序（默认做升序排序）；
  • 存储到 multiset 容器中的元素，虽然其类型没有明确用 const 修饰，但正常情况下它们的值是无法被修改的；
  • multiset容器可以存储多个值相同的元素
包含的方法和使用的规则如同set容器,不再赘述
布鲁克要补钙
关注
专栏目录
C++ | C++ STL关联式容器
I_feige的博客
10-05 219
C++ | C++ STL关联式容器 C++ 容器大致分为 2 类，即序列式容器和关联式容器。 其中，序列式容器（包括 array、vector、list、deque 和 forward_list）。 C++ STL关联式容器 序列式容器，其存储的都是 C++ 基本数据类型（诸如 int、double、float、string 等）或使用结构体自定义类型的元素。 std::vector<int> primes {2, 3, 5, 7, 11, 13, 17, 19};//存储 int 类型元素的
C++ | STL标准库之关联容器
weixin_44742670的博客
12-21 828
文章目录前言一、map二、set三、关联容器迭代器四、无序容器总结 前言 上一篇顺序容器中，元素按照它们在容器中的位置来顺序保存和访问。本文关联容器中，元素是按照关键字来保存和访问的。 关联式容器支持高效的关键字查找和访问，标准库提供了8个关联容器，4个有序：map、set、multimap、multiset ; 4个无序：unordered_map、unordered_set、unordered_multimap、unordered_multiset。这些容器都基于两个主要的关联容器：map和set。
C++ STL关联式容器
最新发布
ershiyidian的博客
06-15 797
考虑到“键值对”并不是普通类型数据，C++STL标准库提供了 pair 类模板，其专门用来将 2 个普通元素 first 和 second（可以是 C++ 基本数据类型、结构体、类自定的类型）创建成一个新元素。通过其构成的元素格式不难看出，使用 pair 类模板来创建“键值对”形式的元素，再合适不过。pair 类模板定义在<utility>头文件中，所以在使用该类模板之前，需引入此头文件。#1) 默认构造函数，即创建空的 pair 对象pair();
c++ | 五种 STL 迭代器
chang466477509的博客
12-30 3096
文章目录一、迭代器是什么？二、迭代器类别输入迭代器输出运算符前向迭代器双向迭代器随机访问迭代器三、不同容器所对应的迭代器类型四、迭代器的定义方式五、代码实现 一、迭代器是什么？ 迭代器是一种抽象的设计理念，通过迭代器可以在不了解容器内部原理的情况下遍历容器。除此之外，STL 中迭代器一个最重要的作用就是作为容器与 STL 算法的粘结剂，只要容器提供迭代器的接口，同一套算法代码可以利用在完全不同的容器中，这是抽象思想的经典应用。 简单来讲，迭代器和 C++ 的指针非常类似，它可以是需要的任意类型，通过迭代器.
【STL八】关联容器
junxuezheng的博客
04-04 780
关联式容器存储的元素，都是一个一个的“键值对”。
C++ | STL | 序列容器 | 关联容器
山城盛夏的博客
07-23 459
C++ | STL | 序列容器 | 关联容器 目录 C++ | STL | 序列容器 | 关联容器 1.前言 2.序列容器 2.1.vector容器 2.2.array容器 2.3.valarray容器 2.4.queue容器 2.5.deque容器 2.6.priority_queue容器 2.7.list容器 2.8.forward_list容器 2.9.bitset容器 2.10.stack容器 3.关联容器 3.1.set容器 3.2.multiset容器 3.
C++——STL容器
JAN6055的博客
02-01 5725
STL容器的介绍 vector, queue, deque, priority_queue, list, map 等等
C++ | STL标准库之顺序容器
weixin_44742670的博客
12-16 1528
前言 STL六大组件中的容器按照结构特征可分为顺序容器（链状）、关联式容器（树状）和无序式容器。本文就其中顺序容器进行总结和介绍。 一、顺序容器概述 标准库顺序容器有：vector、deque、list、forward_list、arry、string。六个顺序容器中，只有arry是固定大小。 vector： string和vector将元素保存在连续的内存空间中，因此由下标计算其地址很方便。但因为其连续的特性，在其中间位置添加或删除元素非常耗时，这可能会移动变动位置之后的所有元素。 注： vect
C++: STL容器
newxuyangcao
05-25 694
C++: 标准模板库(Standard Template Library, STL)容器
【C++】关联式容器
m0_74246469的博客
03-08 1591
set/multiset与map/multimap的运用
SGI STL 关联式容器源码
05-26
通过对SGI STL关联式容器源码的学习，我们可以理解这些数据结构的内部实现，从而更好地利用它们来解决实际编程问题，提高程序效率。同时，这也是深入理解C++模板元编程和STL设计模式的一个宝贵资源。
深入解析C++ STL中的常用容器
12-31
STL中的常用容器包括：顺序性容器（vector、deque、list）、关联容器（map、set）、容器适配器（queue、stac）。 1、顺序性容器 （1）vectorvector是一种动态数组，在内存中具有连续的存储空间，支持快速随机访问。...
C++ | STL之顺序容器、关联容器、容器适配器
ZY-JIMMY
03-23 1955
文章目录STL简述STL六大组件顺序容器（序列式容器）vectordequelist关联容器容器适配器 STL简述 STL是Standard Template Library的简称，中文名标准模板库，从根本上说，STL是一些“容器”的集合，这些“容器”有list、vector、set、map等，STL也是算法和其他一些组件的集合。STL的目的是标准化组件，这样就不用重新开发，可以使用现成的组件。...
计算机网络 TCP/IP模型
LQEmptycity的博客
03-21 4482
文章目录网络IP地址定义分类组成MAC地址网络协议OSI模型和TCP/IP协议族体系数据链路层传输单元主要功能 网络 网络设备有：交换机，路由器，集线器 传输介质有：双绞线，同轴电缆，光纤 IP地址 定义 IP地址是给因特网上每个主机的每一个接口分配的一个在全世界范围内唯一的标识符 分类 IPV4：32位，用"."分成四个段，每段8位，用10进制表示 例：“192.168.31.1” IPV6：128位，每段16位，用4个16进制数表示 例：“2001:0db8:3c4d:00015:0000:0000:
操作系统 || 进程死锁
LQEmptycity的博客
04-20 3150
文章目录死锁定义死锁四个必要条件资源分配图 死锁定义 由于多个并发执行的进程之间竞争资源而导致进程之间“永久”阻塞。在无外力作用下，所有进程都无法向前推进的状态。 当一组进程中的每个进程都在等待某事件（等待所请求资源释放），而只有这组进程中的其他被阻塞的进程才可以触发该进程，就称这组进程发生死锁。 竞争资源 竞争不可剥夺资源 竞争可消耗资源 进程之间推进顺序不当 死锁四个必要条件 互斥。其他进程不能访问 已分配个其他进程的资源 占有且等待。在等待其他资源时，继续占有已分配的资源 不可抢占。不能抢占
Linux || 命令
LQEmptycity的博客
04-08 1874
文章目录文件操作命令进程操作命令网络命令系统监测 文件操作命令 文件类型： f：普通文件 d：目录文件 l：符号链接 p：管道 s：套接文件 touch：创建普通文件 当文件已经存在时，touch命令改变该文件的创建时间 mkdir：创建目录文件 rmdir：删除空目录，不能删除非空目录 rmdir -r name：删除非空目录 cp：拷贝文件，加“-r”拷贝目录文件 cp 旧文件名 新文件名 rm：删除文件 删除目录文件加“-r” 强制删除文件（没有提示）加“-f” 删
c++ || 继承 覆盖 重载
LQEmptycity的博客
11-13 1387
文章目录类与类之间的关系继承隐藏动多态覆盖 甚麽样的函数会出现重载 甚麽样的函数会出现隐藏 甚麽样的函数会出现覆盖 覆盖的函数之间会不会存在隐藏关系 覆盖关系基于隐藏关系 覆盖一定有隐藏 虚函数表的产生 动多态的调用过程 类与类之间的关系 组合 嵌套 — 一个类中声明了另一个类 一个类是另一个类的一部分 代理 — 一个类的接口是另一个类接口的子集 一个类的功能是需要依赖另一个类的功能实现 继承 继承 — 父类：基类 子类：派生类 子类无法访问父类的私有成员 继承权限：public prot
c++ || 详解二叉树
LQEmptycity的博客
08-17 1248
树
c++ || 内存管理_内存分配
LQEmptycity的博客
04-17 1172
文章目录内存分配方式堆与栈的区别指针与数组指针与数组区别指针参数传递内存 本文来源《高质量C++编程》第7章 内存分配方式 从静态存储区域分配 1.在程序编译时就已经分配好 2.在程序整个运行期间都存在 3.全局变量，static变量 在栈上创建 1.局部变量 2.函数结束时存储单元自动释放 3.效率高，但分配内存容量有限 从堆上分配（动态内存分配） 1.malloc，new申请 2.动态内存生存期由程序员决定，使用灵活 堆与栈的区别 堆与栈的区别 管理方式不同。栈由操作系统自
C++ STL入门：关联式容器Sets与Multisets解析
"关联式容器-STL入门教程" 在编程领域，STL（Standard Template Library，标准模板库）是C++编程中不可或缺的一部分，它提供了一系列高效、泛型的容器、迭代器、算法和配接器，极大地提升了代码的复用性和效率。本...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值