map使用时的一个小陷阱

最新推荐文章于 2024-08-14 21:53:13 发布
最新推荐文章于 2024-08-14 21:53:13 发布
阅读量764 收藏 1
点赞数 1
分类专栏： 工作总结 文章标签： class struct null less 工作
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cccbuiler/article/details/1772451
版权

在STL中，map是一种非常灵活的关联容器，在使用map时一定要正确定义_Kty及_Pr。

map在定义如下：

template<class _Kty, class _Ty, class _Pr = less<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> > >
 class map

要实例化一个map首先要确定_Kty与_Ty的类型，其中_Kty为map的键值类型，_Ty为map的数据区的数据类型，_Pr为map比较键值的函数类（默认使用操作符“<”），而_Alloc 为map的配置器（默认使用系统配置器）。在一般情况下，我们只需要确定_Kty与_Ty就可实例化一个map对象。

当实例一个map容器std::map<key,ty> simMap;时，要保存key的操作符“<”可以正常工作，并且保证key类型的数据具有顺序性。

如下是一个错误的定义：

         class  CMapRetryData
        {
         public :
             //  键类型
            typedef  struct  _tagMapItem 
            {
                unsigned  long     m_ulTick;
                unsigned  char     m_ucRetryCount;
                std::auto_ptr < const  SENDDATA >     m_pSendData;
             public :
                _tagMapItem()
                {
                    m_ulTick     =  ::GetTickCount();
                    m_ucRetryCount     =   0 ;
                     // m_pSendData    = NULL;
                }
                _tagMapItem(  const  _tagMapItem &  v_source )
                {
                    m_ulTick     =  v_source.m_ulTick;
                    m_ucRetryCount     =  v_source.m_ucRetryCount;

                     const  SENDDATA *     pSour;
                    SENDDATA *  pDest;
                    m_pSendData     =  std::auto_ptr < const  SENDDATA > ( new  SENDDATA);
                    pSour     =  v_source.m_pSendData. get ();
                     if ( NULL  !=  pSour )
                    {
                        pDest     =  const_cast < SENDDATA *> (m_pSendData. get ());
                        ::memcpy( pDest, pSour,  sizeof (SENDDATA) );
                    }
                     else
                    {
                        m_pSendData.reset();
                    }
                }
                 ~ _tagMapItem()
                {
                    m_pSendData.reset();
                }
            } CMapItem;
             //  内容类型
            typedef  struct  _tagMapKey
            {
                unsigned  long     m_ulTerminaID;
                unsigned  char     m_ucBussType;
                unsigned  char     m_ucDataType;
             public :
                _tagMapKey()
                {
                    m_ulTerminaID     =   0 ;
                    m_ucBussType     =   0 ;
                    m_ucDataType     =   0 ;
                }
                _tagMapKey(  const  _tagMapKey &  v_source )
                {
                    m_ulTerminaID     =  v_source.m_ulTerminaID;
                    m_ucBussType     =  v_source.m_ucBussType;
                    m_ucDataType     =  v_source.m_ucDataType;
                }
                 ~ _tagMapKey()
                {
                }

                 bool   operator   ==  (  const  _tagMapKey &  v_source )  const
                {
                     return  ((m_ulTerminaID  ==  v_source.m_ulTerminaID)  &&
                            (m_ucBussType  ==  v_source.m_ucBussType)  &&
                            (m_ucDataType  ==  v_source.m_ucDataType));
                }
                 bool   operator   <  ( const  _tagMapKey &  v_source )  const
                {
                    // 这里是问题所在
                     return  ((m_ulTerminaID  <  v_source.m_ulTerminaID)  &&
                            (m_ucBussType  <  v_source.m_ucBussType)  &&
                            (m_ucDataType  <  v_source.m_ucDataType));
                }
                 bool   operator   !=  (  const  _tagMapKey &  v_source )  const
                {
                     return  ((m_ulTerminaID  !=  v_source.m_ulTerminaID)  ||
                            (m_ucBussType  !=  v_source.m_ucBussType)  ||
                            (m_ucDataType  !=  v_source.m_ucDataType));
                }
            } CMapKey;
             //  比较类
             class  CCompare
            {
             public :
                 bool   operator () (  const  CMapKey  & v_key1,  const  CMapKey  & v_key2 )  const
                {
                    // 这里是问题所在
                     return  ((v_key1.m_ulTerminaID  >=  v_key2.m_ulTerminaID)  &&
                            (v_key1.m_ucBussType  >=  v_key2.m_ucBussType)  &&
                            (v_key1.m_ucDataType  >=  v_key2.m_ucDataType));
                }
            };
            typedef std::map < CMapKey, CMapItem /* , CCompare */ >  CDataMap;
         public :
            CMapRetryData()
                 // : m_dataMap()
            {
            }
             ~ CMapRetryData()
            {
                m_dataMap.clear();
            }
         private :
             //  Map类
            CDataMap    m_dataMap;
         public :
            CMapItem &   operator [] (  const  CMapKey &  v_key )
            {
                 return     m_dataMap[v_key];
            }

             void  DeleteItem( CMapKey &  v_key )
            {
                m_dataMap.erase(v_key);
            }

             const  SENDDATA *  FindOverTime();
        };

这段代码是一个map的应用，这里map的键值类重载了操作符“<”，也实现了一个比较类CCompare。这里出现的问题j是操作符重符后的键值类型不具有顺序性，例：

 

CMapRetryData::CMapKey    key1, key2;
key1.m_ulTerminaID     =   1 ;
key1.m_ucBussType     =   0x19 ;
key1.m_ucDataType     =   0x01 ;

key2.m_ulTerminaID     =   1 ;
key2.m_ucBussType     =   0x19 ;
key2.m_ucDataType     =   0x02 ;

 //  有如下表达式成立
( key1  <  key2 )  ==   false ;
( key2  <  key1 )  ==   false ;

上述代码说明CMapKey类型没有顺序性，这产生的后果就是不能通过已知的键值查找键值对应的数据内容。

因此，将出错部分进行如下修改：

 

             //  键类型
            typedef  struct  _tagMapKey
            {
                unsigned  long     m_ulTerminaID;
                unsigned  char     m_ucBussType;
                unsigned  char     m_ucDataType;
             public :
                _tagMapKey()
                {
                    m_ulTerminaID     =   0 ;
                    m_ucBussType     =   0 ;
                    m_ucDataType     =   0 ;
                }
                _tagMapKey(  const  _tagMapKey &  v_source )
                {
                    m_ulTerminaID     =  v_source.m_ulTerminaID;
                    m_ucBussType     =  v_source.m_ucBussType;
                    m_ucDataType     =  v_source.m_ucDataType;
                }
                 ~ _tagMapKey()
                {
                }

                 bool   operator   ==  (  const  _tagMapKey &  v_source )  const
                {
                     return  ((m_ulTerminaID  ==  v_source.m_ulTerminaID)  &&
                            (m_ucBussType  ==  v_source.m_ucBussType)  &&
                            (m_ucDataType  ==  v_source.m_ucDataType));
                }
                 bool   operator   <  ( const  _tagMapKey &  v_source )  const
                {
                     return  (m_ulTerminaID  !=  v_source.m_ulTerminaID  ?  m_ulTerminaID  <  v_source.m_ulTerminaID :
                                (m_ucBussType  !=  v_source.m_ucBussType  ?  m_ucBussType  <  v_source.m_ucBussType :
                                    (m_ucDataType  <  v_source.m_ucDataType)));
                     // return ((m_ulTerminaID < v_source.m_ulTerminaID) &&
                     //         (m_ucBussType < v_source.m_ucBussType) &&
                     //         (m_ucDataType < v_source.m_ucDataType));
                }
                 bool   operator   !=  (  const  _tagMapKey &  v_source )  const
                {
                     return  ((m_ulTerminaID  !=  v_source.m_ulTerminaID)  ||
                            (m_ucBussType  !=  v_source.m_ucBussType)  ||
                            (m_ucDataType  !=  v_source.m_ucDataType));
                }
            } CMapKey;
             //  比较类
             class  CCompare
            {
             public :
                 bool   operator () (  const  CMapKey  & v_key1,  const  CMapKey  & v_key2 )  const
                {
                     return  (v_key1.m_ulTerminaID  !=  v_key2.m_ulTerminaID  ?  v_key1.m_ulTerminaID  <  v_key2.m_ulTerminaID :
                                (v_key1.m_ucBussType  !=  v_key2.m_ucBussType  ?  v_key1.m_ucBussType  <  v_key2.m_ucBussType :
                                    (v_key1.m_ucDataType  <  v_key2.m_ucDataType)));
                     // return ((v_key1.m_ulTerminaID >= v_key2.m_ulTerminaID) &&
                     //         (v_key1.m_ucBussType >= v_key2.m_ucBussType) &&
                     //         (v_key1.m_ucDataType >= v_key2.m_ucDataType));
                }
            };
cccbuiler
关注
专栏目录
C++学习（四八三）无法从“std::pair＜const _Kty,_Ty＞”转换为“_Objty”
hankern的专栏
04-10 2169
使用vs2017编译osgEarth2.9的FeatureSourceIndexNode.cpp遇到的 使用VS2017编译osgEarth2.7过程中遇到问题总结_justslowdown_going的博客-CSDN博客>> xmemory0(881): error C2440: “初始化”: 无法从“std::pair<const _Kty,_Ty>”转换为 to _Objty位置：FeatureSourceIndexNode.cpp解决方法：使用osgEarth3.0版本下的
使用easyexcel的一个大陷阱
IceStreamLab
09-07 1563
<!-- 阿里巴巴 EasyExcel依赖 --> <dependency> <groupId>com.alibaba</groupId> <artifactId>easyexcel</artifactId> <version>1.1.1</version> </depen...
error C2664: “std::map<_Kty,_Ty>::map(const std::map<_Kty,_Ty> &)”: 问题解决
qiudesuo的专栏
10-12 1041
今天使用STL的map进行嵌套使用，然后出现这个错误:error C2664: “std::map&lt;_Kty,_Ty&gt;::map(const std::map&lt;_Kty,_Ty&gt; &amp;)”: 不能将参数 1 从“std::map&lt;_Kty,_Ty&gt;”转换为“const std::map&lt;_Kty,_Ty&gt; &amp;” 放上google...
使用VS2017编译osgEarth2.7过程中遇到问题总结
siwen0的博客
01-03 1163
>> xmemory0(881): error C2440: “初始化”: 无法从“std::pair<const _Kty,_Ty>”转换为 to _Objty 位置：FeatureSourceIndexNode.cpp 解决方法：使用osgEarth3.0版本下的“struct KeyIter : public std::iterator<std::input_iterator_tag, typename T::value_type> ”替换掉2.6版本下的“stru
实用经验 69 理解常量成员函数
一鸣惊人的博客
08-13 202
声明带有 const 关键字的成员函数指定，函数是 “只读”函数，在它被调用的时候不会修改对象。 一个常数成员函数不能修改任何非静态数据成员或调用不是常数的任何成员函数。声明常数成员函数，需在参数列表的右括号后放置const关键字。 声明和定义中均需要const 关键字。
const+map引起error C2678的解决办法
laomai的专栏
05-08 7927
写了一个小程序，在一个const成员函数中访问了一个map成员，如下所示： void CPlayerScore::GetScore(GAMERESULT res, RBScore & rbscore)const { rbscore = m_scoreTable[res]; } m_scoreTable是一个map成员，结果编译时报错。 error C2678: 二进
STL里map的第三个参数
learner_pu的博客
06-02 1292
首先看看STL里对map的定义 template<class _Kty, class _Ty, class _Pr = less<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty>>> class map : public _Tree<_Tmap_traits<_Kty, _Ty, _Pr, _Alloc, false>> 第一个是key,第二个是value，第三个是
map使用細節和陷阱.go
09-14
map使用細節和陷阱
STL map容器[]运算符陷阱
liangkdm的专栏
12-29 1162
之前在排查一个界面数据显示出错问题，一开始以为是内存越界导致map里面存的数据出现了异常，经过调试后发现map容器的[]运算符使用中存在陷阱，一不小心容易出错导致内部数据产生变化。          在STL中，map是一个关联式容器，它提供一对一的数据处理能力，即其中每一个元素都是一个键值对，通过一个唯一的关键字，可以唯一映射到对应的数据值。而map中重载了下标运算符[]，通过下标操作，开发
深入理解 Go 语言并发 map 安全使用
最新发布
禅与代码的艺术
08-14 1213
介绍了 Go 语言内建的 map 类型，了解它的基本使用方法和使用陷阱，然后学习如何实现线程安全的 map 类型，最后介绍 Go 标准库中线程安全的 sync.Map 类型以及第三方库。。
15.【Map】_map_
10-02
`HashMap`是`Map`接口的一个常用实现，它使用哈希表实现，提供了快速的插入、删除和查找操作。`HashMap`不保证元素的顺序，且允许`null`键和`null`值。其时间复杂度在理想情况下为O(1)。 三、TreeMap `TreeMap`基于...
QT中的Map
ty_jiang的专栏
06-23 1194
1、可以做一个轻量级的数据库。 2、使用时注意深浅拷贝。 3、不支持更改。更改时需要删除原KEY。
function的深入理解
coolwriter的博客
08-13 500
传统回调函数 #include &lt;iostream&gt; #include &lt;functional&gt; using namespace std; // 传统C函数 int c_function(int a, int b) { return a + b; } // 函数对象 class Functor { public: int operator()(...
c++ map按key或value的值分别进行排序
weixin_30457551的博客
04-04 1126
一、对key值进行特定的排序 map容器里面有两个值一个key一个是value，map<key,value>，其实map里面还有第三个参数，是一个类，用来对map的key进行排序的类，定义如下 template<class _Kty, class _Ty, class _Pr = less<_Kty>, class _Alloc ...
C++ map的坑
qq_44843469的博客
05-20 1515
执行map.erase()函数后如果直接cout的话，size会正常显示，但是用到了下标之后就会增加，是因为用下标显示时当键不存在，会默认创建了一个键值对，但是值为空。 而且输出的时候a.size和下标在一起输出的话就会改变a.size的值，应该是因为cout的原因，它会从后往前计算，先用到了下标a[1],a[5]，size+2，然后输出size=3。 cout的顺序看下边这个博客 cout输出流执行顺序问题 #include<iostream> #include<map> #inc
c++ map::operator[]陷阱——无则插入
winger2010的专栏
02-22 1572
T& operator[] ( const key_type& x ); Access element If x matches the key of an element in the container, the function returns a reference to its mapped value. If x does not match the key of
没有躲过的坑--map查找结果处理
一蓑烟雨任平生 也无风雨也无晴
11-25 9044
通过键-值的方法进行搜索，可以使用map，极大的提高了速度。下面代码就是使用map的find查找，通过键，找出对应的值。map<std::string, int> string_int_map; //对string_int_map进行初始化 map<std::string, int >::iterator iter_string_int; string substring_to
C++ STL操作陷阱：删除map并避坑
首先，关于条件删除map表的部分，作者给出了一个示例代码片段，展示了如何使用`std::list<int>`容器中的迭代器`iter`来删除大于10的元素。使用`eraser()`方法，当找到满足条件的元素时，迭代器会被递增并移除对应的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值