STL中map使用陷阱

最新推荐文章于 2019-01-10 18:01:29 发布
最新推荐文章于 2019-01-10 18:01:29 发布
阅读量2.1k 收藏 1
点赞数
分类专栏： sum 文章标签： stl sgi map pair
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/caft_rp/article/details/49851151
版权
  • 问题描述

       最近在项目开发中使用到了SGI版本的STL中的map，结果遇到了非预期的现象。

  • 问题模拟

       众所周知，map的底层是用红黑树来管理key-value关系的，因此在find时，效率极高，但同样这也带来了某些非预期的空间开销。首先就代码中的使用模型简化如下：

#include <iostream>
#include <string>
#include <map>
#include <set>
using namespace std;

enum PetType
{
    CAT,
    DOG
};

class PetHouse
{
public:
    PetHouse()
    {
        cout << "construct PetHouse ... : " << this << endl;
    }
    ~PetHouse()
    {
        cout << "destruct PetHouse ... : " << this << endl;
    }
};

class Pet
{
public:
    Pet()
    {
        mPetHouse = new PetHouse;
    }
    ~Pet()
    {
        if (NULL != mPetHouse)
        {
            delete mPetHouse;
            mPetHouse = NULL;
        }
    }

public:
    void Adopt(string petName)
    {
        mPets.insert(petName);
    }

private:
    PetHouse *mPetHouse;
    set<string>   mPets;
};

class Lady
{
public:
    Lady()
    {
        cout << "coustruct Lady ... : " << this << endl;
    }
    ~Lady()
    {
        cout << "destruct Lady ... : " << this << endl;
    }

public:
    void AdoptPet(PetType type, string petName)
    {
        const static char *TYPE[] = {"cat", "dog"};

        Pet *ptr = &mPet[type]; // // // // // // #1
        ptr->Adopt(petName);

        cout << "adopt a " << TYPE[type]
            << ", name: " << petName << endl;
    }

private:
    map<PetType, Pet> mPet; // // // // // // //  #2
};

int main()
{
    Lady myWife;

    myWife.AdoptAPet(CAT, "cat0");
    myWife.AdoptAPet(CAT, "cat1");
    myWife.AdoptAPet(DOG, "dog0");
    myWife.AdoptAPet(DOG, "dog1");

    return 0;
}
  • 代码分析

       注意，程序中#2定义map时，map的值为Pet类型；此外，对#1处的map重载的[]作一说明：当map存在待索引的key时，改中括号运算符的结果会返回已存在的key对应的value，否则，新建一对key-value存储到map中并返回新建的key对应的value值。
       诸位觉得运行结果是否会符合预期？

  • 运行结果

       将上述程序分别在OS X平台(STL: MIT)和redhat平台(STL: SGI)上运行，运行结果如下：

      OS X:

$ ./lady
coustruct Lady ... : 0x7fff55e61a30
construct PetHouse ... : 0x7fca71403170
adopt a cat, name: cat0
adopt a cat, name: cat1
construct PetHouse ... : 0x7fca71403200
adopt a dog, name: dog0
adopt a dog, name: dog1
destruct Lady ... : 0x7fff55e61a30
destruct PetHouse ... : 0x7fca71403200
destruct PetHouse ... : 0x7fca71403170

      RedHat:

$./lady
coustruct Lady ... : 0x7fff7884b0d0
construct PetHouse ... : 0x606040
destruct PetHouse ... : 0x606040
destruct PetHouse ... : 0x606040
*** glibc detected *** ./lady: double free or corruption (fasttop): 0x0000000000606040 ***
Aborted (core dumped)
  • 结果分析

      可以看出，在MIT的STL下，上述代码运行正常符合预期；在SGI版的STL下，程序core掉！
首先分析SGI版map的core掉原因。
由输出可见，PetHouse调用了一次构造函数，调用了两次析构函数。这是为何？
对Pet类加入拷贝构造函数改造如下：

class Pet
{
public:
    Pet()
    {
        //mPetHouse = new PetHouse;
        mPetHouse = NULL;
        cout << "construct Pet ... : this" << this << endl;
    }
    ~Pet()
    {
        if (NULL != mPetHouse)
        {
            delete mPetHouse;
            mPetHouse = NULL;
        }

        cout << "destruct Pet ... : this" << this << endl;
    }

    Pet(const Pet &pet)
    {
        mPetHouse = NULL;
        cout << "copy-construct Pet ... : this=" << this
            << "src-pet=" << &pet << endl;
    }    
    ...
};

再次运行，结果如下：

$./lady
coustruct Lady ... : 0x7fff53003390
construct Pet ... : this=0x7fff530032d0
copy-construct Pet ... : this=0x7fff53003298, src-pet=0x7fff530032d0
copy-construct Pet ... : this=0x605068, src-pet=0x7fff53003298
destruct Pet ... : this=0x7fff53003298
destruct Pet ... : this=0x7fff530032d0
adopt a cat, name: cat0
adopt a cat, name: cat1
construct Pet ... : this=0x7fff530032d0
copy-construct Pet ... : this=0x7fff53003298, src-pet=0x7fff530032d0
copy-construct Pet ... : this=0x605198, src-pet=0x7fff53003298
destruct Pet ... : this=0x7fff53003298
destruct Pet ... : this=0x7fff530032d0
adopt a dog, name: dog0
adopt a dog, name: dog1
destruct Lady ... : 0x7fff53003390
destruct Pet ... : this=0x605198
destruct Pet ... : this=0x605068

       可见，Pet对象被构造了一次，拷贝构造了两次，并且由于之前Pet对象并未自定义拷贝构造函数，故程序运行过程中的两次拷贝构造动作都是调用编译器默认生成的默认拷贝构造函数，而编译器生成的拷贝构造函数内只有一个动作，那就是抓住参数对象和自己本身的地址，快速的进行一次字节拷贝，亦即进行一次浅复制，这样就生成了三个Pet对象。在之后对Pet进行析构操作时，由于三个Pet对象中包含的mPetHouse指针指向的是同一个对象，这时问题就出现了，对同一个对象怎么能析构三次呢？？所以，在第一次对Pet析构成功之后再次析构时，程序崩溃！！
      core的原因清楚了，那么为什么调用一次[]运算符，会级联构造三个Pet对象呢？理论上讲只会构造一个Pet对象才对啊？“源码之间，真相大白”！
      阅读SGI版STL中map的operator[]函数实现源码可知，在一次调用时，有如下两个关键点需要注意：
1. operator[]函数

mapped_type&
operator[](const key_type& __k)
{
    // concept requirements
    __glibcxx_function_requires(_DefaultConstructibleConcept<mapped_type>)

    iterator __i = lower_bound(__k);
    // __i->first is greater than or equivalent to __k.
    if (__i == end() || key_comp()(__k, (*__i).first))
          __i = insert(__i, value_type(__k, mapped_type()));  // // // #3
    return (*__i).second;
}

      阅读#3行可知，在未查找到key时，会调用insert函数插入一个新建的value。具体如下：a, mapped_type()会先调用value_type构造函数构造一个待map的对象; b, value_type(__K, mapped_type())会调用pair构造函数构造一个map中存储的真正的pair对象，而pair的构造函数非常暴力:

/** Two objects may be passed to a @c pair constructor to be copied.  */
pair(const _T1& __a, const _T2& __b): first(__a), second(__b) { }

      这样就直接导致了刚通过value_type()构造的对象被再次通过second(__b)拷贝构造一次。
2. 

// map member func @by caft
iterator
insert(iterator position, const value_type& __x)
{ return _M_t.insert_unique(position, __x); }

// _Rb_tree member func @by caft
template<typename _Key, typename _Val, typename _KeyOfValue, typename _Compare, typename _Alloc>
typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
_M_insert(_Base_ptr __x, _Base_ptr __p, const _Val& __v)
{
      bool __insert_left = (__x != 0 || __p == _M_end()
                || _M_impl._M_key_compare(_KeyOfValue()(__v), _S_key(__p)));

      _Link_type __z = _M_create_node(__v); // #4

      _Rb_tree_insert_and_rebalance(__insert_left, __z, __p, this->_M_impl._M_header);
      ++_M_impl._M_node_count;
      return iterator(__z);
}

      经过一番调用后，最终会调用到Rb_tree的insert函数，而在Rb_tree的每个insert函数中都会有#4行所示的操作，即create一个叶子节点用以插入到红黑树中:

_Link_type
_M_create_node(const value_type& __x)
{
    _Link_type __tmp = _M_get_node();
    try
      { get_allocator().construct(&__tmp->_M_value_field, __x); } // #5
    catch(...)
      {
        _M_put_node(__tmp);
        __throw_exception_again;
      }
    return __tmp;
}

      由#5行可知，申请到叶子节点空间后，会接着使用__x的值来初始化(创建)对象，此处即为第二次调用拷贝构造函数。至此，真相大白！
      那为何MIT版的STL中map只调用了一次构造函数就完成了插入动作呢？
      再次阅读MIT版的map::operator[]：

typedef _VSTD::__value_type<key_type, mapped_type>             __value_type;

typedef __tree<__value_type, __vc, __allocator_type>            __base;

typedef unique_ptr<__node, _Dp> __node_holder;

template <class _Key, class _Tp, class _Compare, class _Allocator>
typename map<_Key, _Tp, _Compare, _Allocator>::__node_holder
map<_Key, _Tp, _Compare, _Allocator>::__construct_node_with_key(const key_type& __k)
{
    __node_allocator& __na = __tree_.__node_alloc();
    __node_holder __h(__node_traits::allocate(__na, 1), _Dp(__na));
    __node_traits::construct(__na, _VSTD::addressof(__h->__value_.__cc.first), __k);
    __h.get_deleter().__first_constructed = true;
    __node_traits::construct(__na, _VSTD::addressof(__h->__value_.__cc.second));
    __h.get_deleter().__second_constructed = true;
    return _VSTD::move(__h);  // explicitly moved for C++03
}

template <class _Key, class _Tp, class _Compare, class _Allocator>
_Tp&
map<_Key, _Tp, _Compare, _Allocator>::operator[](const key_type& __k)
{
    __node_base_pointer __parent;
    __node_base_pointer& __child = __find_equal_key(__parent, __k);
    __node_pointer __r = static_cast<__node_pointer>(__child);
    if (__child == nullptr)
    {
        __node_holder __h = __construct_node_with_key(__k); // // #6
        __tree_.__insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__h.get()));
        __r = __h.release();
    }
    return __r->__value_.__cc.second;
}

      由#6行易知，在查找到key不存在时直接创建了一个新的叶子节点，紧接着直接进行insert操作，因此未有间接的两次拷贝构造动作产生。

      综上所述，由于两种版本的map实现的数据结构略有差异，导致相同的代码，用不同的map产生了不同的运行结果。

  • 总结

      由此可见，STL版本的不同可能会产生意想不到的运行结果。为了程序的兼容性更强，也为了空间利用率更高更有效的利用map，笔者建议，map中存储的key，value最好不要出现自定义类型，最好为原生类型，或者是指针类型。

caft
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++ STL map使用问题
whrail的专栏
02-25 4396
      C++的标准库提供的 map类是保存 的键-值对的容器, 操作符[]提供了类似于数组随机访问的语义, 可以通过key来方便地访问或者修改与之对应的value.       另外, STL map作为容器也提供了对应的迭代器 map::iterator, 使我们能够方便的通过iterator遍历map的键-值对成员.      STL map提供的上述接口可以大大简化我们代码
STL MAP使用注意事项
佰大于的小仓库
08-08 393
Hat’s Words   A hat’s word is a word in the dictionary that is the concatenation of exactly two other words in the dictionary.  You are to find all the hat’s words in a dictionary.  InputSta
STL 陷阱或缺陷
痞子龙3D编程
02-03 2055
6.6 Map在Map中移除元素时，当心发生意外状况。当你移除迭代器所指对象时，有一个很大的危险，看看这个例子：typedef map sim;sim coll;sim::iterator pos;.......for(pos = coll.begin(); pos != coll.end(); ++pos) {    if(pos->second == value
STL map使用时的一些问题
weixin_34341117的博客
09-08 90
一般地当我们只想知道一个值是否存在时,set 最有用处;希望存储也可能修改一个相关的值时,map 最为有用. map提供一个键值对容器，在map(也叫关联数组)中我们提供一个键/值对,键用来索引,而值用作被存储和检索的数据. 在使用map和set时两个最主要的动作是向里面放入元素以及查询元素是否存在. 首先要包含头文件 #include <map> 定义并...
关于STL的map的注意事项
weixin_30482181的博客
12-09 115
关于map是什么，这里就不多叙述了。 直接正题，常用的map插入操作有三种方法：通过pair<key_type,value_type>、通过value_type插入数据、还有一种类似于数组的形式插入数据，关键字就是数组下标。 关于三种插入方式的区别：前两者的效果是一样的，但是由于数据集合唯一性，如果一个key对应的value上有值的话，那么再次往这个key上插入一个...
使用STL map应该注意什么
Simon的博客
10-23 382
一句话总结：map的底层实现基于红黑树，是排好序的，key应该能够做比较才行。 如果是结构体怎么办，为了能够比较，那就只能以一个变量作为比较元素，需重载操作符重载可选，但只重载>操作符不行。 #include #include #include using namespace std; struct StudentGrade { string
STL使用注意问题
03-08
在STL中，`vector`、`map`和`list`是三种常见的容器，它们各有特点和适用场景。这里我们将讨论在使用这些容器时需要注意的问题。 1. **向`vector`中增加元素的陷阱** `vector`是一个动态数组，它允许在任意位置...
effective stl
12-14
《Effective STL》是一本关于标准模板库（STL）实践指南的书籍，旨在帮助...以上是《Effective STL》中部分重要知识点的解析，它们涵盖了STL容器的基础知识、最佳实践以及常见陷阱，对提升STL编程水平有着重要意义。
关于STL的erase()陷阱-迭代器失效问题的总结
08-31
本文将深入探讨这个问题，并通过实例分析在不同类型的STL容器中如何安全地使用`erase()`。 首先，让我们来看看两种主要的STL容器类别：按数组形式存储的容器（如`vector`、`deque`）和以不连续的节点形式存储的容器...
effective STL
07-08
《Effective STL》提出了50个实践建议，涵盖了如何避免常见陷阱、提高效率、编写可维护代码和利用STL特性等方面。例如，使用STL的迭代器时要注意其失效条件，避免使用不必要的拷贝操作，以及正确选择容器和算法以...
std::map.find()崩溃怪事
柳鲲鹏
01-10 5988
代码如下（之前已经加锁）： char* pFuncKey = gh_memory_ffl_to_key(pFile, pFunction, nLine); //第二次死在这里，为什么？ std::map&lt;const char*, GhMemoryRecord*&gt;::iterator funcIter = g_oMemoryRecordFunctionMap...
STL_map
Our little drops...
08-21 565
STL_map源码 /** * @brief A standard container made up of (key,value) pairs, which can be * retrieved based on a key, in logarithm
STL MAP内存释放测试
不白
12-03 631
测试过程： insert采用malloc分配内存，释放时采用free释放内存，并erase操作子。使用top窗口查看程序使用的内存。 测试结果： free后，操作系统为程序分配的内存并不会free掉，而被Hold了。当再次调用insert入map，会使用未free掉的内存。 如果后面insert同样采用malloc分配内存，操作系统会优先使用先去malloc且free掉的内存，若不够再ma...
关于std::map中的find和[]的问题
热门推荐
qqwx_1986的专栏
12-09 3万+
     std::map不是顺序容器，这应该都知道的，map中重载了operator []操作符，可以用map的键值索引到相关的数据，但是这个[]和一般数组的[]可不一样。有的人又认为既然[]就是利用下标做索引和std::map中的find用键值索引是不是一样的，所以有的会写出下面类似的代码：std::map mapTemp;...int* Find1(int i){   
C++中 map::at 使用方法
相信坚持的力量……
12-08 1万+
map::at  查找具有指定键值的元素    #include #include using namespace std; int main() { map M; M.insert(map::value_type("Scottding",1)); M.insert(map::value_type("DHL",2)); M.at("Scottdin")++; for(map::
c++使用stl库中的map
最新发布
10-25
C++中的STL库中的map是一种关联式容器，它提供了一种将键映射到值的方法。map中的每个元素都是一个键值对，其中键是唯一的，值可以重复。map中的元素按照键的升序排列，因此可以使用迭代器来遍历map中的元素。map提供了许多方法来插入、删除和查找元素，例如insert、erase和find等。使用STL库中的map可以方便地实现许多常见的数据结构和算法，例如字典、哈希表和二叉搜索树等。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值