cpp►STL容器-＞排序容器-＞set
Posted itzyjr
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了cpp►STL容器-＞排序容器-＞set相关的知识，希望对你有一定的参考价值。
目录
描述
std::set
template <class T, class Compare = less<T>, class Alloc = allocator<T>> class set;
set集合是按特定顺序存储唯一元素的容器。
在set中，元素的值也标识它(值本身是key，类型为T)，并且每个值必须是唯一的。set中元素的值不能在容器中被修改(元素总是常量)，但可以插入或从容器中删除它们。
在内部，set中的元素总是按照其内部比较对象(Compare类型)指示的特定严格弱排序标准进行排序。
set容器通常比unordered_set容器通过key访问单个元素的速度慢，但是它们允许基于其顺序对子集进行直接迭代。
set的典型实现为二进制搜索树。
容器属性(Container properties)
- Associative
关联容器中的元素由其key引用，而不是由其在容器中的绝对位置引用。 - Ordered
容器中的元素始终遵循严格的顺序。所有插入的元素都按此顺序给定一个位置。 - Set
元素的value也是用来标识它的key。 - Unique keys
容器中的任何两个元素都不能有等价的key。 - Allocator-aware
容器使用分配器对象动态处理其存储需求。
成员类型(Member types)
| 成员类型 | 定义 | 备注 |
|---|---|---|
| key_type | 第一个模板参数(T) | |
| value_type | 第一个模板参数(T) | |
| key_compare | 第二个模板参数(Compare) | 默认为：less<key_type> |
| value_compare | 第二个模板参数(Compare) | 默认为：less<value_type> |
成员函数(Member functions)
构造函数：
// constructing sets
#include <iostream>
#include <set>
bool fncomp(int lhs, int rhs) {
return lhs < rhs;
}
struct classcomp {
bool operator() (const int& lhs, const int& rhs) const {
return lhs < rhs;
}
};
int main() {
std::set<int> first;// empty set of ints
int myints[] = { 10,20,30,40,50 };
std::set<int> second(myints, myints + 5);// range
std::set<int> third(second);// a copy of second
std::set<int> fourth(second.begin(), second.end());// iterator ctor.
std::set<int, classcomp> fifth;// class as Compare
bool(*fn_pt)(int, int) = fncomp;
std::set<int, bool(*)(int, int)> sixth(fn_pt);// function pointer as Compare
return 0;
}
修改器(Modifiers)
- emplace_hint
template <class... Args> iterator emplace_hint(const_iterator position, Args&&... args);
作用：
构造并插入带有提示的元素。
返回：
如果成功插入元素，函数返回一个iterator指向新插入的元素。
否则返回一个iterator指向容器中与插入元素相等的元素。
成员类型iterator是一个指向某个元素的双向迭代器。
// set::emplace_hint
#include <iostream>
#include <set>
#include <string>
int main() {
std::set<std::string> myset;
auto it = myset.cbegin();
myset.emplace_hint(it, "alpha");
it = myset.emplace_hint(myset.cend(), "omega");
it = myset.emplace_hint(it, "epsilon");
it = myset.emplace_hint(it, "beta");
std::cout << "myset contains:";
for (const std::string& x : myset)
std::cout << ' ' << x;
return 0;
}
myset contains: alpha beta epsilon omega
观察者(Observers)
- key_comp/value_comp
key_compare key_comp() const;
value_compare value_comp() const;
返回比较对象。默认这个是一个less对象，它的返回与operator<相同。
less对象的定义如下：
template <class T> struct less {
bool operator() (const T& x, const T& y) const {
return x < y;
}
typedef T first_argument_type;
typedef T second_argument_type;
typedef bool result_type;
};
// set::key_comp
#include <iostream>
#include <set>
int main() {
std::set<int> myset;
int highest;
std::set<int>::key_compare mycomp = myset.key_comp();
/*或 std::set<int>::value_compare mycomp = myset.value_comp(); */
for (int i = 0; i <= 5; i++)
myset.insert(i);
std::cout << "myset contains:";
highest = *myset.rbegin();
std::set<int>::iterator it = myset.begin();
do {
std::cout << ' ' << *it;
} while (mycomp(*(++it), highest));
return 0;
}
myset contains: 0 1 2 3 4
操作(Operations)
- find
iterator find(const value_type& value) const;
在容器中搜索等价于val的元素，如果找到则返回迭代器，否则返回迭代器set::end。
如果容器的比较对象反射性地返回false(即，无论元素作为参数传递的顺序如何)，则认为集合中的两个元素是等价的。
// set::find
#include <iostream>
#include <set>
int main(){
std::set<int> myset;
std::set<int>::iterator it;
// set some initial values:
for (int i = 1; i <= 5; i++)
myset.insert(i * 10);// set: 10 20 30 40 50
it = myset.find(20);
myset.erase(it);
myset.erase(myset.find(40));
std::cout << "myset contains:";
for (it = myset.begin(); it != myset.end(); ++it)
std::cout << ' ' << *it;
return 0;
}
myset contains: 10 30 50
- count
size_type count(const value_type& val) const;
对具有特定值的元素进行计数。
因为所有元素在set容器里都是唯一的，所以函数只可能返回0或1。
// set::count
#include <iostream>
#include <set>
int main() {
std::set<int> myset;
// set some initial values:
for (int i = 1; i < 5; ++i)
myset.insert(i * 3);// set: 3 6 9 12
for (int i = 0; i < 10; ++i) {
std::cout << i;
if (myset.count(i) != 0)
std::cout << " is an element of myset.\\n";
else
std::cout << " is not an element of myset.\\n";
}
return 0;
}
0 is not an element of myset.
1 is not an element of myset.
2 is not an element of myset.
3 is an element of myset.
4 is not an element of myset.
5 is not an element of myset.
6 is an element of myset.
7 is not an element of myset.
8 is not an element of myset.
9 is an element of myset.
- lower_bound、upper_bound
iterator lower_bound(const value_type& val) const;
返回一个迭代器，该迭代器指向等于val或在val之后的第一个元素。
iterator upper_bound(const value_type& val) const;
返回一个迭代器，该迭代器指向在val之后的第一个元素。
// set::lower_bound/upper_bound
#include <iostream>
#include <set>
int main() {
std::set<int> myset;
std::set<int>::iterator itlow, itup;
for (int i = 1; i < 10; i++)
myset.insert(i * 10);// 10 20 30 40 50 60 70 80 90
itlow = myset.lower_bound(30);// *itlow==30
itup = myset.upper_bound(60);// *itup==70
myset.erase(itlow, itup);// 10 20 70 80 90
std::cout << "myset contains:";
for (std::set<int>::iterator it = myset.begin(); it != myset.end(); ++it)
std::cout << ' ' << *it;
return 0;
}
myset contains: 10 20 70 80 90
- equal_range
pair<iterator, iterator> equal_range(const value_type& val) const;
返回包含容器中与val等价的所有元素的范围的边界。
因为集合容器中的所有元素都是唯一的，所以返回的范围最多只包含一个元素。
函数返回一个pair，其成员pair::first是范围的下限(与lower_bound相同)，pair::second是上限(与upper_bound相同)。
// set::equal_elements
#include <iostream>
#include <set>
int main() {
std::set<int> myset;
for (int i = 1; i <= 5; i++)
myset.insert(i * 10);// myset: 10 20 30 40 50
std::pair<std::set<int>::const_iterator, std::set<int>::const_iterator> ret;
ret = myset.equal_range(30);
std::cout << "the lower bound points to: " << *ret.first << '\\n';
std::cout << "the upper bound points to: " << *ret.second << '\\n';
return 0;
}
the lower bound points to: 30
the upper bound points to: 40
std::pair
template <class T1, class T2> struct pair;
这个类将一对不同类型的值(T1和T2)耦合在一起。单个值可以通过其公共成员(first和second)访问。
模板参数T1：成员first的类型，别名为first_type。
模板参数T2：成员second的类型，别名为second_type。
成员变量：first——pair里的第一个值；second——pair里的第二个值。
以上是关于cpp►STL容器-＞排序容器-＞set的主要内容，如果未能解决你的问题，请参考以下文章