c++ map 使用自定义结构做关键字

最新推荐文章于 2024-03-11 14:19:35 发布
最新推荐文章于 2024-03-11 14:19:35 发布
阅读量8.4k 收藏 12
点赞数 5
分类专栏： C++ 文章标签： Map 自定义关键字

map在STL中的定义

template <class Key, class T, class Compare = less<Key>, class Alloc = alloc>

 第一个参数Key是关键字类型

第二个参数T是值类型

第三个参数Compare是比较函数（仿函数）

第四个参数是内存配置对象

map内部存储机制实际是以红黑树为基础，红黑树在插入节点时，必须依照大小比对之后在一个合适的位置上执行插入动作。所以作为关键字，起码必须有“<”这个比较操作符。我们知道，int，float，enum，size_t等等简单关键字，都有内置的比较函数，与map搭配无论是插入还是查找，都没什么问题。但是作为复杂数据类型，如果没有明确定义“<”比较操作符，就不能与map直接搭配使用，除非我们自己定义第三个参数。

在选择map的关键字时，注意以下两点，同时这两点也是改错的方法：

a） 关键字明确定义“<”比较操作符

b） 没有“<”比较操作符，自定义仿函数替代第三个参数Compare，该仿函数实现“()”操作符，提供比较功能。插入时各节点顺序以该仿函数为纲。

以std::pair为关键字掺入map
下面我们先写一个有错误的函数，在分析错误原因之后，逐步进行修正。

#include <map>
int main()
{
       std::map<std::pair<int, int>, int> res;
       res.insert(std::make_pair(12,33), 33);
}

 这个程序一定失败，如果非要如此使用，上述a方法显然不适合，std::pair是已定义好的结构体不可修改。只能使用b方法了，定义一个比较类改造如下：

    #include <map>  
      
    struct comp  
      
    {  
      
           typedef std::pair<int, int> value_type;  
      
           bool operator () (const value_type & ls, const value_type &rs)  
      
           {  
      
                  return ls.first < rs.first || (ls.first == rs.first && ls.second < rs.second);  
      
           }  
      
    };  
      
    int main()  
      
    {  
      
           std::map<std::pair<int, int>, int, comp> res;  
      
           res.insert(std::make_pair(std::make_pair(12,33), 33));  
      
           res.insert(std::make_pair(std::make_pair(121,331), 331));  
      
           res.insert(std::make_pair(std::make_pair(122,332), 332));  
      
            
      
           std::map<std::pair<int, int>, int, comp>::iterator it = res.find(std::make_pair(121,331));  
      
           if (it == res.end())  
      
                  printf("NULL"n");  
      
           else  
      
                  printf("%d %d %d "n", it->first.first, it->first.second, it->second);  
      
        return 0;  
      
    }

以结构体或类为关键字插入map

    #include <map>  
      
    struct st  
      
    {  
      
           int a, b;  
      
           st():a(0), b(0){}  
      
           st(int x, int y):a(x), b(y){}  
      
    };  
      
    int main()  
      
    {  
      
           std::map<struct st, int> res;  
      
           res.insert(std::make_pair(st(1,2), 12));  
      
           res.insert(std::make_pair(st(30,4), 34));  
      
           res.insert(std::make_pair(st(5,6), 56));  
      
            
      
           std::map<struct st, int>::iterator it = res.find(st(30,4));  
      
           if (it == res.end())  
      
                  printf("NULL"n");  
      
           else  
      
                  printf("first:%d second:%d %d"n", it->first.a, it->first.b, it->second);  
      
           return 0;  
      
    }

编译这个程序也是错误的，错误意思大概也是没有定义“<”比较函数。因为struct st是我们自己定义的结构体，所以修改这个程序可以使用上面a、b两种方法。我们先谈第一种，第一次修改时我也搞错了，我是这样定义比较函数的。

    struct st  
      
    {  
      
           int a, b;  
      
           st():a(0), b(0){}  
      
           st(int x, int y):a(x), b(y){}  
      
    bool operator < (const struct st &rs) {return (this->a < rs.a || (this->a == rs.a && this->b < rs.b));}  
      
    };

按照这个改动再次编译程序还是错误，有个如下这样的提示：

/usr/include/c++/3.2.3/bits/stl_function.h:197: passing `const st' as `this' argument of `bool st::operator<(const st&)' discards qualifiers

   为什么会出现这个 问题呢？我们深入STL的源代码看下。既然说是/usr/include/c++/3.2.3/bits/stl_function.h的197行出了问题，且看这行是什么。

／／ One of the @link s20_3_3_comparisons comparison functors@endlink.

    template <class _Tp>

    struct less : public binary_function<_Tp,_Tp,bool>

   　{

         bool operator()(const _Tp& __x, const _Tp& __y) const { return __x < __y; }

   　 };

 

struct st中的“<”在编译后真正是什么样子呢？大概是bool operator < (struct st &ls, const struct st &rs)。在less调用这个比较符时，它都是以const方式传入，不可能再以非const方式调用，故出错。修正如下

struct st

{

       int a, b;

       st():a(0), b(0){}

       st(int x, int y):a(x), b(y){}

       friend bool operator < (const struct st &ls, const struct st &rs);

};

inline bool operator < (const struct st &ls, const struct st &rs)

{return (ls.a < rs.a || (ls.a == rs.a && ls.b < rs.b));}

 以友联函数代替函数内部定义的比较操作符，STL内部也多是以这种方式定义的。如果我非要以内部定义的方式呢？可以使用b方法，我们自定义一个比较仿函数，替代默认的less。

插入函数返回值
       在map容器中插入数据有很多函数可用，这里只讨论最普通的insert操作，在STL中它是这样定义的。

       pair<iterator, bool> insert(const value_type& x);

       map容器不允许键值重复，在执行插入操作后，可以凭借该返回值获取操作结果。返回值是一个迭代器和布尔值的键值对，迭代器指向map中具有该值的元素，布尔值表示是否插入成功。如果布尔值为true，表示插入成功，则迭代器为新插入值在map中的位置；布尔值为false，表示插入失败（已经存在该值），迭代器为原有值在map中的位置。

    #include <map>  
    #include <iostream>  
    using namespace std;  
      
    class Key  
    {  
    public:  
        Key();  
        Key(int v);  
        int _key;  
        ~Key();  
        /*重载<作为成员函数不行，两个操作数都要求是const*/  
        //bool operator <(const Key& key);  
    };  
    bool operator <(const Key &key1,const Key &key2)  
    {  
        if(key1._key<key2._key)  
            return true;  
        else  
            return false;  
    }  
    Key::Key()  
    {  
    }  
    Key::Key(int v)  
    {  
        _key=v;  
    }  
    Key::~Key()  
    {  
    }  
      
    void main()  
    {  
          
        map<Key,int> ClassMap;  
        Key one(1);  
        ClassMap.insert(make_pair(one,1));  
        Key two(2);  
        ClassMap.insert(make_pair(two,2));  
        Key three(3);  
        ClassMap.insert(make_pair(three,3));  
        map<Key,int>::iterator itor=ClassMap.begin();  
        while(itor!=ClassMap.end())  
        {  
            cout<<itor->first._key<<" ~~ "<<itor->second<<endl;  
            ++itor;  
        }  
    }

　以上内容是转载　http://blog.csdn.net/xie376450483/archive/2011/04/17/6329408.aspx



纠正上例中的一个错误，重载<的时候，也可以这么做：

#include <map>  
    #include <iostream>  
    using namespace std;  
      
    class Key  
    {  
    public:  
        Key();  
        Key(int v);  
        int _key;  
        ~Key();  
       
        bool operator <(const Key& key) const;  
    };  
    bool Key::operator <(const Key &key)  const
    {  
        if(this->_key<key._key)  
            return true;  
        else  
            return false;  
    }  
    Key::Key()  
    {  
    }  
    Key::Key(int v)  
    {  
        _key=v;  
    }  
    Key::~Key()  
    {  
    }  
      
    void main()  
    {  
          
        map<Key,int> ClassMap;  
        Key one(1);  
        ClassMap.insert(make_pair(one,1));  
        Key two(2);  
        ClassMap.insert(make_pair(two,2));  
        Key three(3);  
        ClassMap.insert(make_pair(three,3));  
        map<Key,int>::iterator itor=ClassMap.begin();  
        while(itor!=ClassMap.end())  
        {  
            cout<<itor->first._key<<" ~~ "<<itor->second<<endl;  
            ++itor;  
        }  
    }



zhubaohua_bupt
关注
  • 5
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
＜C++＞map 容器快速上手 自定义数据类型排序的避坑理解_c++ map自定义类型(2)
pasehelpme的博客
05-05 271
与set容器一样，定义排序规则需要在创建容器的时候就指定，同样需要借助仿函数，也就是后面会提到的谓词进行自定义数据类型排序的时候要注意，使用仿函数定义排序规则是针对键的，因此要把定义的类、结构体放在泛型的第一个参数上（别问，问就是我看了半天源码才发现的…）// 自定义数据类型排序class Heropublic:// 构造方法// 属性int age;public:Hero h1("赵云", 42);Hero h2("曹操", 43);Hero h3("孙策", 39);
【C++】自定义结构体作为map的key
二十三小时
11-18 8282
自定义结构体作为C/C++中的map，或是unordered_map的key值： /** * self defined struct as the key of map in c++ */ struct K { int n1, n2; K(int i, int j): n1(i), n2(j) {} // the operator < defines the operation
突破编程_C++_STL教程（ map 的实战应用）
最新发布
突破编程
03-11 928
C++ STL教程： map 的实战应用
将自定义结构存入std::set 或者 std::map
Zx13170918986的博客
11-07 339
众所周知，std::set和std::map的底层使用红黑树作为排序算法，并且默认是升序排列。 但是当我们的键值是一个结构体或者类的时候该怎么办呢 ？ 可以看到set的模板是这样实现的，默认比较函数是std::less 而less的底层实现是这样的 所以，照葫芦画瓢，当我们想要使用自定义结构作为键值的时候便可以自定义一个比较函数 仅举例set，map用法相同 struct stru {......
map中字符串与结构体作key效率比较
03-11
比较两者查找效率，得出结论是结构体比字符串组合快～～～
map的键使用自定义结构体
学而不思则罔
06-24 1928
背景: map的定义 template, class A = allocator > 可见,map的定义是一个模板类,模板参数为Key,T,Pred,A,各参数的含义如下:Key---------键T------------值Pred--------map用于比较键的类,这个类必须重载()操作符,在其中定义比较操作..(虽然比较怪,不是重载大于小于号
C++中自定义结构体作为map的主键
Edidaughter的博客
07-14 2265
在一个需求中，如果其map的主键是一个自定义的结构题，会和简单的如string类型，int类型的结构体作为主键有什么不一样呢？我们来试一试.
std::map 如何使用结构体作为自定义键值
热门推荐
GreenArrowMan-CSDN博客
03-15 1万+
在使用map时，有时候我们需要自定义键值，才能符合程序的需要。 比如我们需要使用自定义的结构体来作为map的键值.
c++ map中key为结构体
qq_34462436的博客
08-14 3057
map中key为结构体 项目中需要将结构体作为hash的key，一开始用hash_map，但是结构体中多值比较一直失败，所以尝试了map。 hash_map 查找速度会比map快，而且查找速度基本和数据量大小无关，属于常数级别;而map的查找速度是log(n)级别。hash还有hash函数的耗时。当有100w条记录的时候，map也只需要20次的比较，200w也只需要21次的比较！所以并不一定常数就比log(n) 小。 hash_map对空间的要求要比map高很多，所以是以空间换时间的方法，而且，hash_m
c++数据结构的复习题目
08-09
理解它们的差异及如何使用，有助于创建自定义数据结构。 5. **链表**：链表是一种线性数据结构，其元素不是连续存储的。链表包括单链表、双向链表和循环链表。了解链表节点的定义、插入、删除操作以及链表遍历是...
数据结构的C++语言实现
06-28
在C++中，可以使用数组或动态分配的内存（通过`new`关键字）来实现。数组适合静态大小的线性表，而链表则允许在运行时动态添加或删除元素。 2. **栈和队列**：栈是一种后进先出（LIFO）的数据结构，常用于表达式求...
数据结构C++语言描述
04-20
此外，C++模板机制使得我们能创建自定义的抽象数据类型（ADT），例如通过继承抽象基类或使用STL中的iterator概念来设计自己的容器。 容器类库STL（Standard Template Library）是C++的重要组成部分，它包括容器、...
C&&C++知识体系结构图
09-09
C和C++的知识体系结构图通常会以图形方式展示这些概念的层次关系和相互联系，帮助学习者理解并构建清晰的知识框架。"c语言知识体系.png"和"c++知识体系 (2).png"可能是这样的可视化表示，它们将有助于你直观地掌握这...
C++编程实例100篇
08-28
C++提供了多种基本数据类型，如int、float、char等，以及复杂的自定义数据类型如结构体和类。运算符用于执行数学或逻辑操作，如算术运算符(+、-、*、/、%)和逻辑运算符(&&、||、!)。控制结构如条件语句(if...else)和...
C++字符串切分: split实现
yangalbert的专栏
10-06 9547
std::vector split(const std::string& s, const std::string& delim) { std::vector elems; size_t pos = 0; size_t len = s.length(); size_t delim_len = delim.length(); if (delim_len ==
c++ STL map 结构体
Lemoneasy的专栏
12-10 5589
点击打开链接 点击打开链接 Map是STL的一个关联容器，它提供一对一（其中第一个可以称为关键字，每个关键字只能在map中出现一次，第二个可能称为该关键字的值）的数据处理能力，由于这个特性，它完成有可能在我们处理一对一数据的时候，在编程上提供快速通道。这里说下map内部数据的组织，map内部自建一颗红黑树(一种非严格意义上的平衡二叉树)，这颗树具有对数据自动排序的功能，所以在m
C++ STL map key是自定义结构体或类
EastonWoo的专栏
11-02 9337
/// @file 1.cpp /// @brief /// @author EastonWoo /// 0.01 /// @date 2015-11-02 #include #include #include #include #include #include class CKey{ public: CKey(std::string str1, std::stri
＜C++＞map 容器快速上手|自定义数据类型排序的避坑理解
微凉秋意的博客
11-14 2795
继 set 容器后，今天总结一下 map 容器的功能，从零到一快速掌握基本使用与常用接口。map 在STL 编程中与 vector、list、set 具有同等重要的地位，键值对的方式存储元素在查找时很是高效，那么下面正式开始 map 容器的学习之旅。
std::map使用结构体自定义键值
weixin_30832405的博客
04-30 1731
使用STL中的map时候，有时候需要使用结构题自定义键值，比如想统计点的坐标出现的次数 struct Node{ int x,y; }; ...... map<Node,int>mp; mp[(Node){x,y}]++; 　　这样子的话，会出现一堆报错 c:\mingw\lib\gcc\mingw32\4.8.1\include\c++...
c++自定义类 多关键字排序
07-18
### 回答1： 在Python中，我们可以通过自定义类来实现多关键字排序。 首先，我们可以在自定义类的构造函数中设置需要排序的关键字。假设我们需要按照学生的年龄（age）和成绩（score）两个关键字进行排序，我们可以这样定义一个Student类： ```python class Student: def __init__(self, name, age, score): self.name = name self.age = age self.score = score ``` 接下来，我们可以使用内置的`sorted()`函数来进行排序。为了实现多关键字排序，我们可以使用`key`参数传入一个函数，该函数可以根据我们的需求来定义排序的规则。 例如，如果我们想要按照年龄升序、成绩降序的方式对学生列表进行排序，可以定义一个排序函数： ```python def sort_key(student): return (student.age, -student.score) ``` 接下来，我们可以使用`sorted()`函数进行排序： ```python students = [ Student("Tom", 20, 80), Student("Alice", 18, 90), Student("Bob", 20, 70) ] sorted_students = sorted(students, key=sort_key) ``` 执行后，`sorted_students`列表将按照我们定义的排序规则进行排序。 在这个例子中，`sort_key`函数返回一个元组，元组中的第一个元素是年龄，第二个元素是成绩的负值。这样可以保证年龄相同时，按照成绩的降序进行排序。 以上便是使用自定义类实现多关键字排序的方法。通过定义排序函数，我们可以根据需要对多个关键字进行排序操作。 ### 回答2： 在Python中，我们可以使用多关键字排序来对自定义类进行排序。 首先，我们需要定义一个自定义类，该类可以包含多个属性（关键字）。假设我们的自定义类为Person，具有属性name、age和salary。 我们可以通过重写类的特殊方法__lt__（小于）、__eq__（等于）和__gt__（大于）来实现对类对象的排序。这些方法分别表示对象之间的小于、等于和大于的比较操作。在这些方法中，我们可以根据需要指定对象之间的比较条件。 以下是一个简单的示例代码： ```python class Person: def __init__(self, name, age, salary): self.name = name self.age = age self.salary = salary def __lt__(self, other): if self.name != other.name: return self.name < other.name if self.age != other.age: return self.age < other.age return self.salary < other.salary def __eq__(self, other): return self.name == other.name and self.age == other.age and self.salary == other.salary def __gt__(self, other): return not self.__lt__(other) and not self.__eq__(other) # 创建Person对象的列表 persons = [Person("张三", 25, 5000), Person("李四", 25, 6000), Person("王五", 30, 5000)] # 根据多个关键字进行排序 persons.sort() # 输出排序结果 for person in persons: print(person.name, person.age, person.salary) ``` 以上代码创建了一个Person类，其中定义了__lt__、__eq__和__gt__方法，用于实现对象之间的比较操作。然后，我们创建了一个Person对象的列表，并使用sort方法对其进行排序。最后，我们按照指定的关键字顺序输出排序结果。 这样，就可以使用多关键字对自定义类进行排序了。 ### 回答3： 在自定义类中，可以通过重写比较方法来实现多关键字排序。 首先，需要定义一个包含多个属性的类，每个属性都代表了一个关键字。然后，在该类中重写比较方法，使其按照指定的排序顺序进行比较。 例如，假设我们要定义一个Person类，包含姓名(name)、年龄(age)和身高(height)三个属性。我们可以按照姓名升序、年龄降序、身高降序的顺序来排序。 首先，我们定义Person类： ```java public class Person { private String name; private int age; private double height; // 构造方法、getter和setter方法省略 // 重写比较方法 public int compareTo(Person other) { // 按照姓名升序排序 int result = this.name.compareTo(other.name); if (result != 0) { return result; } // 按照年龄降序排序 result = other.age - this.age; if (result != 0) { return result; } // 按照身高降序排序 return (int) (other.height - this.height); } } ``` 接着，我们可以使用该自定义类进行排序。例如，创建一个Person对象的列表，然后使用Collections.sort()方法进行排序： ```java List<Person> personList = new ArrayList<>(); personList.add(new Person("Tom", 25, 180)); personList.add(new Person("Jerry", 30, 170)); personList.add(new Person("Alice", 20, 160)); Collections.sort(personList); for (Person person : personList) { System.out.println(person.getName()); } ``` 以上代码会按照姓名升序、年龄降序、身高降序的顺序输出人员的姓名： ``` Alice Jerry Tom ``` 这样，我们就通过重写比较方法，在自定义类中实现了多关键字排序。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值