STL关联容器详解之set

最新推荐文章于 2024-01-15 21:53:45 发布
最新推荐文章于 2024-01-15 21:53:45 发布
阅读量461 收藏
点赞数
分类专栏： C++基础 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/andyjkt/article/details/116457528
版权
本文详细介绍了C++ STL中的Set容器，包括其特性、初始化方法、插入和删除元素的操作，以及相关成员函数的使用。Set容器存储键值对，元素唯一且自动排序，不支持直接修改元素值。文章还提到了Multiset容器，它是Set容器的变体，允许存储重复元素。
摘要由CSDN通过智能技术生成

参考链接

set 容器

使用 set 容器存储的各个键值对，要求键 key 和值 value 必须相等。基于 set 容器的这种特性，当使用 set 容器存储键值对时，只需要为其提供各键值对中的 value 值（也就是 key 的值）即可。
使用 set 容器存储的各个元素的值必须各不相同。

切勿尝试直接修改 set 容器中已存储元素的值，这很有可能破坏 set 容器中元素的有序性，最正确的修改 set 容器中元素值的做法是：先删除该元素，然后再添加一个修改后的元素。

set 容器定义于<set>头文件，并位于 std 命名空间中。

创建set容器的几种方法

  • 调用默认构造函数，创建空的 set 容器:

    std::set<std::string> myset;

    该容器采用默认的std::less<T>规则，会对存储的 string 类型元素做升序排序。

  • 在创建 set 容器的同时，对其进行初始化。

    std::set<std::string> myset{"http://c.biancheng.net/java/",
                            "http://c.biancheng.net/stl/",
                            "http://c.biancheng.net/python/"};

  • 在创建新 set 容器的同时，将已有 set 容器中存储的所有元素全部复制到新 set 容器中。

    std::set<std::string> copyset(myset);
//等同于
//std::set<std::string> copyset = myset

  • 创建新 set 容器的同时，利用临时的 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;
}
std::set<std::string> copyset(retSet());
//或者
//std::set<std::string> copyset = retSet();

    由于 retSet() 函数的返回值是一个临时 set 容器，因此在初始化 copyset 容器时，其内部调用的是 set 类模板中的移动构造函数，而非拷贝构造函数。

  • 取已有 set 容器中的部分元素，来初始化新 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容器的成员方法

成员方法功能
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
#include <iostream>
#include <set>
#include <string>
using namespace std;
int main()
{
    //创建空set容器
    std::set<std::string> myset;
    //空set容器不存储任何元素
    cout << "1、myset size = " << myset.size() << endl;
    //向myset容器中插入新元素
    myset.insert("http://c.biancheng.net/java/");
    myset.insert("http://c.biancheng.net/stl/");
    myset.insert("http://c.biancheng.net/python/");
    cout << "2、myset size = " << myset.size() << endl;
    //利用双向迭代器，遍历myset
    for (auto iter = myset.begin(); iter != myset.end(); ++iter) {
        cout << *iter << endl;
    }
    return 0;
}

set容器迭代器

set 容器类模板中未提供 at() 成员函数，也未对 [] 运算符进行重载。因此，要想访问 set 容器中存储的元素，只能借助 set 容器的迭代器。
C++ STL 标准库为 set 容器配置的迭代器类型为双向迭代器。这意味着，假设 p 为此类型的迭代器，则其只能进行 ++p、p++、–p、p–、*p 操作，并且 2 个双向迭代器之间做比较，也只能使用 == 或者 != 运算符。
begin()/end()

#include <iostream>
#include <set>
#include <string>
using namespace std;
int main()
{
    //创建并初始化set容器
    std::set<std::string> myset{ "http://c.biancheng.net/java/",
                                 "http://c.biancheng.net/stl/",
                                 "http://c.biancheng.net/python/"
    };
    //利用双向迭代器，遍历myset
    for (auto iter = myset.begin(); iter != myset.end(); ++iter) {
        cout << *iter << endl;
    }
    return 0;
}

因为 iter 迭代器指向的是 set 容器存储的某个元素，而不是键值对，因此通过 *iter 可以直接获取该迭代器指向的元素的值。

如果只想遍历 set 容器中指定区域内的部分数据，则可以借助 find()、lower_bound() 以及 upper_bound() 实现。通过调用它们，可以获取一个指向指定元素的迭代器。

equal_range(val) 函数的返回值是一个 pair 类型数据，其包含 2 个迭代器，表示 set 容器中和指定参数 val 相等的元素所在的区域，但由于 set 容器中存储的元素各不相等，因此该函数返回的这 2 个迭代器所表示的范围中，最多只会包含 1 个元素。

#include <iostream>
#include <set>
#include <string>
using namespace std;
int main()
{
    //创建并初始化set容器
    std::set<std::string> myset{ "http://c.biancheng.net/java/",
                                 "http://c.biancheng.net/stl/",
                                 "http://c.biancheng.net/python/"
    };
   
    set<string>::iterator iter = myset.find("http://c.biancheng.net/python/");
    for (;iter != myset.end();++iter)
    {
        cout << *iter << endl;
    }
    return 0;
}

set 类模板中包含 lower_bound()、upper_bound()、equal_range() 这 3 个成员函数，但它们更适用于 multiset 容器，几乎不会用于操作 set 容器。

set insert()方法

  • 只要给定目标元素的值，insert() 方法即可将该元素添加到 set 容器中

    //普通引用方式传参
pair<iterator,bool> insert (const value_type& val);
//右值引用方式传参
pair<iterator,bool> insert (value_type&& val);

    val 表示要添加的新元素，该方法的返回值为 pair 类型。
    以上 2 种语法格式的 insert() 方法，返回的都是 pair 类型的值，其包含 2 个数据，一个迭代器和一个 bool 值：

    • 当向 set 容器添加元素成功时，该迭代器指向 set 容器新添加的元素，bool 类型的值为 true；
    • 如果添加失败，即证明原 set 容器中已存有相同的元素，此时返回的迭代器就指向容器中相同的此元素，同时 bool 类型的值为 false。
    #include <iostream>
#include <set>
#include <string>
using namespace std;
int main()
{
    //创建并初始化set容器
    std::set<std::string> myset;
    //准备接受 insert() 的返回值
    pair<set<string>::iterator, bool> retpair;
    //采用普通引用传值方式
    string str = "http://c.biancheng.net/stl/";
    retpair = myset.insert(str);
    cout << "iter->" << *(retpair.first) << " " << "bool = " << retpair.second << endl;
    //采用右值引用传值方式
    retpair = myset.insert("http://c.biancheng.net/python/");
    cout << "iter->" << *(retpair.first) << " " << "bool = " << retpair.second << endl;
    return 0;
}

  • insert() 还可以指定将新元素插入到 set 容器中的具体位置

    //以普通引用的方式传递 val 值
iterator insert (const_iterator position, const value_type& val);
//以右值引用的方式传递 val 值
iterator insert (const_iterator position, value_type&& val);

    以上 2 种语法格式中，insert() 函数的返回值为迭代器：

    • 当向 set 容器添加元素成功时，该迭代器指向容器中新添加的元素；
    • 当添加失败时，证明原 set 容器中已有相同的元素，该迭代器就指向 set 容器中相同的这个元素。
    #include <iostream>
#include <set>
#include <string>
using namespace std;
int main()
{
    //创建并初始化set容器
    std::set<std::string> myset;
    //准备接受 insert() 的返回值
    set<string>::iterator iter;
    //采用普通引用传值方式
    string str = "http://c.biancheng.net/stl/";
    iter = myset.insert(myset.begin(),str);
    cout << "myset size =" << myset.size() << endl;
    //采用右值引用传值方式
    iter = myset.insert(myset.end(),"http://c.biancheng.net/python/");
    cout << "myset size =" << myset.size() << endl;
    return 0;
}

    使用 insert() 方法将目标元素插入到 set 容器指定位置后，如果该元素破坏了容器内部的有序状态，set 容器还会自行对新元素的位置做进一步调整。也就是说，insert() 方法中指定新元素插入的位置，并不一定就是该元素最终所处的位置。

  • 向当前 set 容器中插入其它 set 容器指定区域内的所有元素，只要这 2 个 set 容器存储的元素类型相同即可。

    template <class InputIterator>
  void insert (InputIterator first, InputIterator last);

    其中 first 和 last 都是迭代器，它们的组合 [first,last) 可以表示另一 set 容器中的一块区域，该区域包括 first 迭代器指向的元素，但不包含 last 迭代器指向的元素。

    #include <iostream>
#include <set>
#include <string>
using namespace std;
int main()
{
    //创建并初始化set容器
    std::set<std::string> myset{ "http://c.biancheng.net/stl/",
                                "http://c.biancheng.net/python/",
                                "http://c.biancheng.net/java/" };
    //创建一个同类型的空 set 容器
    std::set<std::string> otherset;
    //利用 myset 初始化 otherset
    otherset.insert(++myset.begin(), myset.end());
    //输出 otherset 容器中的元素
    for (auto iter = otherset.begin(); iter != otherset.end(); ++iter) {
        cout << *iter << endl;
    }
    return 0;
}

  • 采用如下格式的 insert() 方法，可实现一次向 set 容器中添加多个元素：

    void insert ( {E1, E2,...,En} );

    #include <iostream>
#include <set>
#include <string>
using namespace std;
int main()
{
    //创建并初始化set容器
    std::set<std::string> myset;
    //向 myset 中添加多个元素
    myset.insert({ "http://c.biancheng.net/stl/",
        "http://c.biancheng.net/python/",
        "http://c.biancheng.net/java/" });
    for (auto iter = myset.begin(); iter != myset.end(); ++iter) {
        cout << *iter << endl;
    }
    return 0;
}

emplace()和emplace_hint()

emplace()

template <class... Args>
  pair<iterator,bool> emplace (Args&&... args);

参数 (Args&&… args) 指的是，只需要传入构建新元素所需的数据即可，该方法可以自行利用这些数据构建出要添加的元素。

该方法的返回值类型为 pair 类型，其包含 2 个元素，一个迭代器和一个 bool 值：

  • 当该方法将目标元素成功添加到 set 容器中时，其返回的迭代器指向新插入的元素，同时 bool 值为 true；
  • 当添加失败时，则表明原 set 容器中已存在相同值的元素，此时返回的迭代器指向容器中具有相同键的这个元素，同时 bool 值为 false。
#include <iostream>
#include <set>
#include <string>
using namespace std;
int main()
{
    //创建并初始化 set 容器
    std::set<string>myset;
    //向 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;
}

emplace_hint()

template <class... Args>
  iterator emplace_hint (const_iterator position, Args&&... args);
  • 该方法需要额外传入一个迭代器，用来指明新元素添加到 set 容器的具体位置（新元素会添加到该迭代器指向元素的前面）；
  • 返回值是一个迭代器，而不再是 pair 对象。当成功添加元素时，返回的迭代器指向新添加的元素；反之，如果添加失败，则迭代器就指向 set 容器和要添加元素的值相同的元素。
#include <iostream>
#include <set>
#include <string>
using namespace std;
int main()
{
    //创建并初始化 set 容器
    std::set<string>myset;
    //在 set 容器的指定位置添加键值对
    set<string>::iterator iter = myset.emplace_hint(myset.begin(), "http://c.biancheng.net/stl/");
    cout << "myset size = " << myset.size() << endl;
    cout << *iter << endl;
    return 0;
}

set删除数据：erase()和clear()方法

erase()

//删除 set 容器中值为 val 的元素
size_type erase (const value_type& val);
//删除 position 迭代器指向的元素
iterator  erase (const_iterator position);
//删除 [first,last) 区间内的所有元素
iterator  erase (const_iterator first, const_iterator last);

第 1 种格式的 erase() 方法，其返回值为一个整数，表示成功删除的元素个数；后 2 种格式的 erase() 方法，返回值都是迭代器，其指向的是 set 容器中删除元素之后的第一个元素。

#include <iostream>
#include <set>
#include <string>
using namespace std;
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) 调用第三种格式的 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;
    return 0;
}

clear()

删除 set 容器中存储的所有元素

#include <iostream>
#include <set>
#include <string>
using namespace std;
int main()
{
    //创建并初始化 set 容器
    std::set<int>myset{1,2,3,4,5};
    cout << "1、myset size = " << myset.size() << endl;
    //清空 myset 容器
    myset.clear();
    cout << "2、myset size = " << myset.size() << endl;
    return 0;
}

multiset容器

set 容器具有以下几个特性：

  • 不再以键值对的方式存储数据，因为 set 容器专门用于存储键和值相等的键值对，因此该容器中真正存储的是各个键值对的值（value）；
  • set 容器在存储数据时，会根据各元素值的大小对存储的元素进行排序（默认做升序排序）；
  • 存储到 set 容器中的元素，虽然其类型没有明确用 const 修饰，但正常情况下它们的值是无法被修改的；
  • set 容器存储的元素必须互不相等。

multiset 容器遵循 set 容器的前 3 个特性，仅在第 4 条特性上有差异。和 set 容器不同的是，multiset 容器可以存储多个值相同的元素。
multiset 类模板也定义在<set>头文件，并位于 std 命名空间中。

创建multiset容器的方法

  • 调用默认构造函数，创建空的 multiset 容器

    std::multiset<std::string> mymultiset;

  • 在创建 multiset 容器的同时，对其进行初始化。

    std::multiset<std::string> mymultiset{ "http://c.biancheng.net/java/",
                                       "http://c.biancheng.net/stl/",
                                       "http://c.biancheng.net/python/" };

  • 在创建新 multiset 容器的同时，将已有 multiset 容器中存储的所有元素全部复制到新 multiset 容器中。

    std::multiset<std::string> copymultiset(mymultiset);
//等同于
//std::multiset<std::string> copymultiset = mymultiset;

    创建新 multiset 容器的同时，利用临时的 multiset 容器为其初始化。

    multiset<string> retMultiset() {
    std::multiset<std::string> tempmultiset{ "http://c.biancheng.net/java/",
                            "http://c.biancheng.net/stl/",
                            "http://c.biancheng.net/python/" };
    return tempmultiset;
}
std::multiset<std::string> copymultiset(retMultiset());
//等同于
//std::multiset<std::string> copymultiset = retMultiset();

    由于 retMultiset() 函数的返回值是一个临时 multiset 容器，因此在初始化 copymultiset 容器时，其内部调用的是 multiset 类模板中的移动构造函数，而非拷贝构造函数。

  • 取已有 multiset 容器中的部分元素，来初始化新 multiset 容器。

    std::multiset<std::string> mymultiset{ "http://c.biancheng.net/java/",
                                       "http://c.biancheng.net/stl/",
                                       "http://c.biancheng.net/python/" };
std::set<std::string> copymultiset(++mymultiset.begin(), mymultiset.end());

  • 手动修改 multiset 容器中的排序规则。

    std::multiset<std::string, std::greater<string> > mymultiset{
    "http://c.biancheng.net/java/",
    "http://c.biancheng.net/stl/",
    "http://c.biancheng.net/python/" };

multiset容器的成员方法

成员方法功能
begin()返回指向容器中第一个（注意，是已排好序的第一个）元素的双向迭代器。如果 multiset 容器用 const 限定，则该方法返回的是 const 类型的双向迭代器。
end()返回指向容器最后一个元素（注意，是已排好序的最后一个）所在位置后一个位置的双向迭代器，通常和 begin() 结合使用。如果 multiset 容器用 const 限定，则该方法返回的是 const 类型的双向迭代器。
rbegin()返回指向最后一个（注意，是已排好序的最后一个）元素的反向双向迭代器。如果 multiset 容器用 const 限定，则该方法返回的是 const 类型的反向双向迭代器。
rend()返回指向第一个（注意，是已排好序的第一个）元素所在位置前一个位置的反向双向迭代器。如果 multiset 容器用 const 限定，则该方法返回的是 const 类型的反向双向迭代器。
cbegin()和 begin() 功能相同，只不过在其基础上，增加了 const 属性，不能用于修改容器内存储的元素值。
cend()和 end() 功能相同，只不过在其基础上，增加了 const 属性，不能用于修改容器内存储的元素值。
crbegin()和 rbegin() 功能相同，只不过在其基础上，增加了 const 属性，不能用于修改容器内存储的元素值。
crend()和 rend() 功能相同，只不过在其基础上，增加了 const 属性，不能用于修改容器内存储的元素值
find(val)在 multiset 容器中查找值为 val 的元素，如果成功找到，则返回指向该元素的双向迭代器；反之，则返回和 end() 方法一样的迭代器。另外，如果 multiset 容器用 const 限定，则该方法返回的是 const 类型的双向迭代器。
lower_bound(val)返回一个指向当前 multiset 容器中第一个大于或等于 val 的元素的双向迭代器。如果 multiset 容器用 const 限定，则该方法返回的是 const 类型的双向迭代器。
upper_bound(val)返回一个指向当前 multiset 容器中第一个大于 val 的元素的迭代器。如果 multiset 容器用 const 限定，则该方法返回的是 const 类型的双向迭代器。
equal_range(val)该方法返回一个 pair 对象（包含 2 个双向迭代器），其中 pair.first 和 lower_bound() 方法的返回值等价，pair.second 和 upper_bound() 方法的返回值等价。也就是说，该方法将返回一个范围，该范围中包含所有值为 val 的元素。
empty()若容器为空，则返回 true；否则 false。
size()返回当前 multiset 容器中存有元素的个数。
max_size()返回 multiset 容器所能容纳元素的最大个数，不同的操作系统，其返回值亦不相同。
insert()向 multiset 容器中插入元素。
erase()删除 multiset 容器中存储的指定元素。
swap()交换 2 个 multiset 容器中存储的所有元素。这意味着，操作的 2 个 multiset 容器的类型必须相同。
clear()清空 multiset 容器中所有的元素，即令 multiset 容器的 size() 为 0。
emplace()在当前 multiset 容器中的指定位置直接构造新元素。其效果和 insert() 一样，但效率更高。
emplace_hint()本质上和 emplace() 在 multiset 容器中构造新元素的方式是一样的，不同之处在于，使用者必须为该方法提供一个指示新元素生成位置的迭代器，并作为该方法的第一个参数。
count(val)在当前 multiset 容器中，查找值为 val 的元素的个数，并返回。

由于 multiset 容器允许存储多个值相同的元素，因此诸如 count()、find()、lower_bound()、upper_bound()、equal_range()等方法，更常用于 multiset 容器。

#include <iostream>
#include <set>
#include <string>
using namespace std;
int main() {
    std::multiset<int> mymultiset{1,2,2,2,3,4,5};
    cout << "multiset size = " << mymultiset.size() << endl;
    cout << "multiset count(2) =" << mymultiset.count(2) << endl;
    //向容器中添加元素 8
    mymultiset.insert(8);
    //删除容器中所有值为 2 的元素
    int num = mymultiset.erase(2);
    cout << "删除了 " << num << " 个元素 2" << endl;
    //输出容器中存储的所有元素
    for (auto iter = mymultiset.begin(); iter != mymultiset.end(); ++iter) {
        cout << *iter << " ";
    }
    return 0;
}
STL3：容器-set
k0512的博客
03-25 645
STL3：容器-set1、简介2、操作2.1 初始化2.2 基本操作（1）迭代器（2）数据量操作2.3 添加数据（1）insert插入数据（2）insert指定位置插入数据2.4 遍历（1）迭代器for循环（2）for_each()循环[推荐]（3）C++11auto迭代器写法（4）C++11 for-loop-scope迭代器写法[推荐]（5）C++11 for_each()与lamdba表达式2.5 查找（1）count()判断值是否存在（2）find()判断值是否存在以及位置2.6 区域查找2.7 删
＜stl系类＞ map和set详解，掌握stl容器从现在开始
weixin_59371851的博客
08-25 672
哈喽，小伙伴们大家好。今天我们继续来学习STL容器，今天我将主要介绍map和set的使用。话不多说，拿好小本本，我们赶快开始吧。一、关联式容器1、关联式容器概念在之前我们接触过STL的部分容器，比如vector，deque，list。这些容器统称为序列式容器，底层为线性结构，存储的是元素本身。那什么是关联式容器呢？关联式容器也是用来存储数据的，与序列式容器不同的是，关联式容器中存储的结构的键值对，有助于数据检索。...
9 STL【set介绍】【set创建】【添加/删除set元素】【multiset】
日月既往，不可复追
04-19 2053
文章目录0 - 前言1 - set是什么2 - set的创建3 - set成员函数4 - 迭代器5 - set添加元素insertemplaceemplace_hint6 - set删除元素eraseclear7 - multiset7 - 1 创建multiset7 - 2 multiset成员函数 0 - 前言 参考：C++ STL set容器完全攻略（超级详细） 1 - set是什么 和 map、multimap 容器不同，使用 set 容器存储的各个键值对，要求键 key 和值 value 必须
第3关：STL模板之关联容器：集合set的操作详解
m0_74014212的博客
05-25 1261
中的一种标准关联容器，其底层数据结构是基于平衡搜索树（红黑树）实现的，插入删除等操作都是通过迭代器指针实现的，不涉及内存操作，因此效率非常高。中的元素在数据结构中是有序存储的（默认升序），为了高效的实现插入、删除和查找等操作，这与数学上的集合中元素无序性有点区别。为了完成本关任务，你需要掌握：1.集合的概念，2.插入元素，3.删除元素，4.遍历集合，5.查找元素，6.清空集合。遍历集合：首先在一行输出集合的大小，然后在下一行输出集合所有元素，中间空格隔开，末尾换行；方法实现，清空后集合的大小。
STL详解（七） 集合容器set
流年的博客
02-01 1242
一、set简介 C++ STL 之所以得到广泛的赞誉，也被很多人使用，不只是提供了像vector, string, list等方便的容器，更重要的是STL封装了许多复杂的数据结构算法和大量常用数据结构操作。vector封装数组，list封装了链表，map和set封装了二叉树，pair封装二元结构体等，在封装这些数据结构的时候，STL按照程序员的使用习惯，以成员函数方式提供的常用操作，如：插入、排...
STL教程之容器--（3）关联式容器（set/multiset、map/multimap）
王木木
09-22 579
关联式容器其实就是关联数组概念的推广，依据选定的排序准则，自动为其元素排序。通常关联式容器是由二叉树做出来的，每个元素都有一个父节点和两个子节点，左子树的所有元素都比自己小，右子树的所有元素都比自己大。关联式容器的差别在于元素的类型以及处理重复元素的方式。关联式容器有一个很大的优点就是提供了对元素的快速访问，但是却不能实现任意位置的操作。 1、set/multiset类模板 集合是一种随机存取的容...
c++关联容器用法详解（set与map）
01-27
C++中的关联容器是STL（Standard Template Library）的一部分，它们包括了set和map等容器。这些容器的主要特点是它们的元素不是按照它们在容器中的位置排序，而是通过一个关键字（key）来组织和访问，提供了高效的...
STL常用容器详细解析
01-20
STL中的常用容器包括：顺序性容器（vector、deque、list）、关联容器（map、set）、容器适配器（queue、stac）。 1、顺序性容器 （1）vectorvector是一种动态数组，在内存中具有连续的存储空间，支持快速随机访问。...
STL中的关联容器详解
本文将介绍什么是STL以及关联容器的特性和用途，重点详细介绍STL中的关联容器，并探讨其适用性和优点。 ## 1.2 目的 本文的目的是帮助读者了解STL中的关联容器，并掌握其基本操作和应用场景。通过学习本文，读者...
STL中的关联容器：set、map、multiset、multimap详解
顺序容器包括vector、deque、list、forward_list、array等，而关联容器则包括set、map、multiset、multimap等。 ## 1.3 关联容器概念和特点 关联容器是一种将值和键关联起来的容器，其特点是内部元素是按照键的大小...
STL
xlp的acm专栏
07-11 478
begin() 返回指向第一个元素的迭代器 clear() 清除所有元素 count() 返回某个值元素的个数 empty() 如果集合为空，返回true(真） end() 返回指向最后一个元素之后的迭代器，不是最后一个元素 equal_range() 返回集合中与给定值相等的上下限的两个迭代器 erase() 删除集合中的元素 find() 返回一个指向被查找到元素的迭代器 get_alloca
STL关联式容器之集合set
handsomeKyne
07-13 515
这一节，我们将学习STL关联式容器集合——set。 1、set的特性 所有元素都会根据元素的键值自动排列，set的键值就是实值，并且set不允许两个元素相同的键值。 2、我们可以通过set的迭代器改变set的元素值吗？ 答案是不行，因为set的元素值就是键值，因此这关系到排列规则，如果我们擅自修改元素值，会破坏set内部的排列规则。也正因为这样，STL的set的迭代器是const_iter
set插入和删除
嵌入式
07-04 6204
功能描述： set容器进行插入数据和删除数据 函数原型： insert(elem); //在容器中插入元素。 clear(); //清除所有元素 erase(pos); //删除pos迭代器所指的元素，返回下一个元素的迭代器。 erase(beg, end); //删除区间[beg,end)的所有元素 ...
python中的集合 (set) 的创建和使用
matinal 當冬夜漸暖 。公众号：matinal
07-27 1178
可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。s1.update({100:'aa',200:'bb',300:'cc',400:'dd'}) # 传递一个字典作为参数。update() 将一个集合中的元素添加到当前集合中，update()可以传递序列或字典作为参数，字典只会使用键。通过set()来将序列和字典转换为集合，使用set()将字典转换为集合时，只会包含字典中的键。方法一：使用{ }来创建集合。
C++STL——关联式容器(set集合)超详细！！！
Rudy1124的博客
08-28 114
多些做题多些用，熟悉了就容易了，兄弟萌，加油哈哈哈！文章尚有不足，欢迎dalao指正。
C++ 标准模板库（STL）_有序关联容器—— set +multiset（迭代器失效问题）（侯捷老师）
JMW1407的博客
06-24 488
STL—— set+multisetSet + multiset1、顺序（序列式）容器和关联容器1.1、顺序容器和关联容器定义1.2、顺序容器和关联容器分类2、set + multiset定义2.1、 set 定义2.1.1、 set 特点2.1.2、 插入效率和迭代器失效问题说明2.2、 multiset 定义3、RB-tree结点的定义3.1、rb_tree结构定义部分源码3.1.1、__rb_tree_node_base定义部分源码4、Set结构部分源码5、multiset结构部分源码6、set常见操
C++——STL标准模板库——容器详解——set
最新发布
qq_42106610的博客
01-15 1997
set容器和multiset容器详解。第一次接触对组的概念。使用中要小心迭代过程中插入或者删除元素迭代器迭代器失效的可能性。
STL之set（集合）详解
qq_36721032的博客
08-26 1194
STL之set（集合）详解一、基本概念二、常用函数2.1、构造/析构函数2.1.1、构造函数2.1.2、析构函数2.1.3、等号操作符2.2、迭代器 一、基本概念 集合是存储排序键的关联容器，其中每个键都是唯一的，可以插入或删除但不能更改。 语法： template < class T, // set::key_type/value_type class Compare = less<T>, //
C++ STL 之集合 set 详解
一些笔记
12-29 574
C++ STL 之 集合 set 关联式容器详解
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值