投稿
  1. 首页
  2. 随笔

STL关联式容器详解

4389小游戏 • 2022-12-15 • 随笔 • 阅读 16

STL关联式容器详解,第1张

STL关联式容器详解 STL关联式容器类别

1. map
定义在 头文件中，使用该容器存储的数据，其各个元素的键必须是唯一的（即不能重复），该容器会根据各元素键的大小，默认进行升序排序（调用 std::less）。
2. set
定义在 头文件中，使用该容器存储的数据，各个元素键和值完全相同，且各个元素的值不能重复（保证了各元素键的唯一性）。该容器会自动根据各个元素的键（其实也就是元素值）的大小进行升序排序（调用 std::less）。
3. multimap
定义在 头文件中，和 map 容器唯一的不同在于，multimap 容器中存储元素的键可以重复。
4. multiset
定义在 头文件中，和 set 容器唯一的不同在于，multiset 容器中存储元素的值可以重复（一旦值重复，则意味着键也是重复的）。

map 不允许键重复

考虑到“键值对”并不是普通类型数据，C++ STL 标准库提供了 pair 类模板，其专门用来将 2 个普通元素 first 和 second
还为 pair 对象重载了 <、<=、>、>=、==、!= 这 6 的运算符，其运算规则是：对于进行比较的 2 个 pair 对象，先比较 pair.first 元素的大小，如果相等则继续比较 pair.second 元素的大小。

#include
using namespace std;
pairp; 
map >m;
int main(){
	pair  pair1("STL教程", 20);
	pair  pair3("C++教程", 30);
//	相当于修改键值 
    pair  pair2("C++教程", 20);
    
	m.insert(pair1);
	m.insert(pair2);
	m.insert(pair3);
	for(auto it:m){
		cout< 


 从大到小排序
 

#include
using namespace std;
pairp; 
map >m;//从大到小 
int main(){
	
	pair  pair2("C++教程", 30);
	pair  pair1("STL教程", 20);
    
	m.insert(pair1);
	m.insert(pair2);
	for(auto it:m){
		cout< 


 常用成员方法
 

  • find(key) 
     在 map 容器中查找键为 key 的键值对，如果成功找到，则返回指向该键值对的双向迭代器；反之，则返回和 end() 方法一样的迭代器。另外，如果 map 容器用 const 限定，则该方法返回的是 const 类型的双向迭代器。
 

#include
using namespace std;
pairp; 
mapm;//从大到小 
int main(){
	
	pair  pair2("C++教程", 30);
	pair  pair1("STL教程", 20);
    
	m.insert(pair1);
	m.insert(pair2);
	auto it=m.find("C++教程");
	if(it!=m.end()){
		cout<second<second< 

 

  • lower_bound(key) 
     返回一个指向当前 map 容器中第一个大于或等于 key 的键值对的双向迭代器。如果 map 容器用 const 限定，则该方法返回的是 const 类型的双向迭代器。
  • upper_bound(key) 
     返回一个指向当前 map 容器中第一个大于 key 的键值对的迭代器。如果 map 容器用 const 限定，则该方法返回的是 const 类型的双向迭代器。
 

#include
using namespace std;
pairp; 
mapm;
int main(){
	
	pair  pair2("C++教程", 30);
	pair  pair1("STL教程", 20);
    pair  pair3("Java教程", 50);
	m.insert(pair1);
	m.insert(pair2);
	m.insert(pair3);
	auto it=m.lower_bound("C++");
	//找到第一个键的值不小于 "Java教程" 的键值对
	cout << "lower：" << it->first << " " << it->second << endl;
	 //找到第一个键的值大于 "Java教程" 的键值对
	it=m.upper_bound("M");
	cout <<"upper：" << it->first << " " << it->second << endl;
	return 0;
} 

 

 

  • equal_range(key) 
     该方法返回一个 pair 对象（包含 2 个双向迭代器），其中 pair.first 和 lower_bound() 方法的返回值等价，pair.second 和 upper_bound() 方法的返回值等价。也就是说，该方法将返回一个范围，该范围中包含的键为 key 的键值对（map 容器键值对唯一，因此该范围最多包含一个键值对）。
 

#include
using namespace std;
pairp; 
mapm;
int main(){
	
	pair  pair2("C++教程", 30);
	pair  pair1("STL教程", 20);
    pair  pair3("Java教程", 50);
    pair  pair4("Java", 50);
	m.insert(pair1);
	m.insert(pair2);
	m.insert(pair3);
	m.insert(pair4);
	pair::iterator,map::iterator >it;
	it=m.equal_range("Java");
	for (auto iter = it.first; iter != it.second; ++iter) {
        cout << iter->first << " " << iter->second << endl;
    }
	cout<first<<" "<second< 

 

  • empty() 
     若容器为空，则返回 true；否则 false。
  • size() 
     返回当前 map 容器中存有键值对的个数。
  • max_size() 
     返回 map 容器所能容纳键值对的最大个数，不同的 *** 作系统，其返回值亦不相同。
  • operator[] 
     map容器重载了 [] 运算符，只要知道 map 容器中某个键值对的键的值，就可以向获取数组中元素那样，通过键直接获取对应的值。
 

#include
using namespace std;
pairp; 
mapm;
int main(){
	
	pair  pair2("C++教程", 30);
	pair  pair1("STL教程", 20);
    pair  pair3("Java教程", 50);
    pair  pair4("Java", 50);
	m.insert(pair1);
	m.insert(pair2);
	m.insert(pair3);
	m.insert(pair4);
	cout<<"empty:"< 

 

  • 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。
 

#include
using namespace std;
pairp; 
mapm,m1;
int main(){
	
	pair  pair2("C++教程", 30);
	pair  pair1("STL教程", 20);
    pair  pair3("Java教程", 50);
    pair  pair4("Java", 50);
	m.insert(pair1);
	m.insert(pair2);
	m.insert(pair3);
	m1.insert(pair4);
	cout<<"at:成功"< 

 
multimap 允许键重复 

  • find(key) 
     在 multimap 容器中查找首个键为 key 的键值对，如果成功找到，则返回指向该键值对的双向迭代器；反之，则返回和 end() 方法一样的迭代器。另外，如果 multimap 容器用 const 限定，则该方法返回的是 const 类型的双向迭代器。
  • lower_bound(key) 
     返回一个指向当前 multimap 容器中第一个大于或等于 key 的键值对的双向迭代器。如果 multimap 容器用 const 限定，则该方法返回的是 const 类型的双向迭代器。
  • upper_bound(key) 
     返回一个指向当前 multimap 容器中第一个大于 key 的键值对的迭代器。如果 multimap 容器用 const 限定，则该方法返回的是 const 类型的双向迭代器。
  • equal_range(key) 
     该方法返回一个 pair 对象（包含 2 个双向迭代器），其中 pair.first 和 lower_bound() 方法的返回值等价，pair.second 和 upper_bound() 方法的返回值等价。也就是说，该方法将返回一个范围，该范围中包含的键为 key 的键值对。
  • empty() 
     若容器为空，则返回 true；否则 false。
  • size() 
     返回当前 multimap 容器中存有键值对的个数。
  • max_size() 
     返回 multimap 容器所能容纳键值对的最大个数，不同的 *** 作系统，其返回值亦不相同。
  • insert() 
     向 multimap 容器中插入键值对。
  • erase() 
     删除 multimap 容器指定位置、指定键（key）值或者指定区域内的键值对。
  • swap() 
     交换 2 个 multimap 容器中存储的键值对，这意味着， *** 作的 2 个键值对的类型必须相同。
  • clear() 
     清空 multimap 容器中所有的键值对，使 multimap 容器的 size() 为 0。
  • emplace() 
     在当前 multimap 容器中的指定位置处构造新键值对。其效果和插入键值对一样，但效率更高。
  • emplace_hint() 
     在本质上和 emplace() 在 multimap 容器中构造新键值对的方式是一样的，不同之处在于，使用者必须为该方法提供一个指示键值对生成位置的迭代器，并作为该方法的第一个参数。
  • count(key) 
     在当前 multimap 容器中，查找键为 key 的键值对的个数并返回。
     用法参照map
 
set 要求键 key 和值 value 必须相等 不能重复 

  • 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。
     用法参展map
 
multisetset 要求键 key 和值 value 必须相等 能重复 

  • 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 的元素的个数，并返回。
     用法参照map
 
自定义排序 

STL标准库适用于关联式容器的排序规则
 

  • std::less 
     底层采用 < 运算符实现升序排序，各关联式容器默认采用的排序规则。
  • std::greater 
     底层采用 > 运算符实现降序排序，同样适用于各个关联式容器。
  • std::less_equal 
     底层采用 <= 运算符实现升序排序，多用于 multimap 和 multiset 容器。
  • std::greater_equal 
     底层采用 >= 运算符实现降序排序，多用于 multimap 和 multiset 容器。
 

#include
using namespace std;
pairp; 
map >m;
//map >m;
//multimap >m;
//multimap >m;
int main(){
	
	pair  pair2("C++教程", 30);
	pair  pair1("STL教程", 20);
//	pair  pair5("STL教程", 90);
    pair  pair3("Java教程", 50);
    pair  pair4("Java", 50);
	m.insert(pair1);
	m.insert(pair2);
	m.insert(pair3);
	m.insert(pair4);
//	m.insert(pair5);
	for(auto it:m){
		cout< 

重载方式排序
 

set
 

#include
using namespace std;

//定义函数对象类
struct cmp{
	//重载 () 运算符
	bool operator()(const string &a,const string &b){
		//按照字符串的长度，做非降排序(即存储的字符串从短到长)
		return a.length()<=b.length();
	}
};
sets;
int main(){
	s.insert("32222");
	s.insert("22222");
	s.insert("111");
	s.insert("33");
	s.insert("444444");
	for(auto it:s){
		cout< 

 

map+vector
 

#include
using namespace std;

typedef struct Node
{
    int num,i;
} node;

typedef pair PAIR;
//map输入时的键排序规则 
struct Cmp
{
    bool operator () (node const &a,node const &b)const
    {
        if(a.num!=b.num)
            return a.numb.second;
    }
}
int main()
{
    srand((unsigned)time(NULL));
    multimapmp;
    int n;
    cin>>n;
    int a,b;
    node no;
    for(int i=0; i(no,i));
    }
    map::iterator iter;
    cout<<"排序前:"<first.num  iter->first.i  iter->second"<first.num<<"                "<first.i<<"                "<second<vec(mp.begin(),mp.end());
    sort(vec.begin(),vec.end(),cmp);
    int size=vec.size();
    cout<<"vec[i].first.num  vec[i].first.i   vec[i].second"< 

					
										


					

						
欢迎分享，转载请注明来源：内存溢出
原文地址: http://www.outofmemory.cn/zaji/5609777.html
赞 (0)
打赏 微信扫一扫 微信扫一扫 支付宝扫一扫 支付宝扫一扫
4389小游戏 4389小游戏 一级用户组
0 0
上一篇 2022-12-15
下一篇 2022-12-15

发表评论

登录后才能评论

评论列表（0条）

保存