【问题标题】:Why is memory still accessible after std::map::clear() is called?为什么调用 std::map::clear() 后内存仍然可以访问?
【发布时间】:2010-10-08 19:41:09
【问题描述】:

我正在观察 std::map::clear() 的奇怪行为。此方法应该在调用时调用元素的析构函数,但是调用 clear() 后仍然可以访问内存。

例如:

struct A
{
  ~A() { x = 0; }
  int x;
};

int main( void )
{
  std::map< int, A * > my_map;
  A *a = new A();
  a->x = 5;
  my_map.insert( std::make_pair< int, *A >( 0, a ) );

  // addresses will be the same, will print 5
  std::cout << a << " " << my_map[0] << " " << my_map[0]->x << std::endl;

  my_map.clear();

  // will be 0
  std::cout << a->x << std::endl;

  return 0;
}

问题是,为什么变量a 在其析构函数被map::clear() 调用后仍然可以访问?在调用my_map.clear() 之后是否需要写delete a; 或者覆盖a 的内容是否安全?

提前感谢您的帮助, 斯内格

【问题讨论】:

  • 尝试使用 at() 访问它不会让您访问不存在的东西例如:ideone.com/ZeRTnd(尽管之前定义了带有键“B”的项目,在 map.clear() 之后试图访问密钥“B”会让你得到'std::out_of_range' 异常

标签: c++ stdmap


【解决方案1】:

在过去 2 个月的饮食、睡眠和呼吸地图上,我有一个建议。尽可能让地图分配它自己的数据。由于您在此处强调的原因,它更清洁了。

还有一些微妙的优势,比如如果你将数据从文件或套接字复制到地图的数据中,只要节点存在,数据存储就存在,因为当地图调用 malloc() 分配节点时,它为键和数据分配内存。 (又名 map[key].first 和 map[key].second)

这允许您使用赋值运算符而不是 memcpy(),并且需要对 malloc() 的调用减少 1 次 - 您所做的那个。

IC_CDR CDR, *pThisCDRLeafData;  // a large struct{}

    while(1 == fread(CDR, sizeof(CDR), 1, fp))  {
    if(feof(fp)) {
        printf("\nfread() failure in %s at line %i", __FILE__, __LINE__);
    }
    cdrMap[CDR.iGUID] = CDR; // no need for a malloc() and memcpy() here    
    pThisCDRLeafData  = &cdrMap[CDR.iGUID]; // pointer to tree node's data

需要注意的一些注意事项在这里值得指出。

  1. 不要在添加树节点的代码行中调用 malloc() 或 new,因为您对 malloc() 的调用将在映射调用 malloc() 分配一个位置来保存您的返回值之前返回一个指针malloc()。
  2. 在调试模式下,尝试 free() 内存时可能会遇到类似问题。这两个对我来说似乎都是编译器问题,但至少在 MSVC 2012 中,它们存在并且是一个严重的问题。
  3. 想一想在哪里“锚定”您的地图。 IE:声明它们的地方。您不希望它们错误地超出范围。 main{} 始终是安全的。

    INT _tmain(INT argc, char* argv[])    {
    IC_CDR      CDR, *pThisCDRLeafData=NULL;
    CDR_MAP     cdrMap;
    CUST_MAP    custMap;
    KCI_MAP     kciMap;
    
  4. 我很幸运,很高兴有一个关键映射分配一个结构作为节点数据,并让该结构“锚定”一个映射。虽然 C++ 已经放弃了匿名结构(一个必须撤销的可怕决定),但作为第一个结构成员的映射就像匿名结构一样工作。非常光滑和干净,尺寸效应为零。在函数调用中传递指向叶拥有的结构的指针,或按值传递结构的副本,两者都工作得很好。强烈推荐。

  5. 您可以捕获 .insert 的返回值,以确定它是在该键上找到现有节点,还是创建了一个新节点。 (代码见#12)使用下标表示法不允许这样做。选择 .insert 并坚持下去可能会更好,特别是因为 [] 符号不适用于多图。 (这样做是没有意义的,因为没有“a”键,而是多重映射中具有相同值的一系列键)
  6. 您可以而且应该捕获 .erase 和 .empty() 的返回值(是的,有些东西是函数,需要 (),而有些像 .erase,则不需要)
  7. 您可以使用 .first 和 .second 获取任何地图节点的键值和数据值,按照惯例,所有地图都使用它们分别返回键和数据
  8. 为您自己节省大量的混乱和打字,并为您的地图使用 typedef,就像这样。

    typedef map<ULLNG, IC_CDR>      CDR_MAP;    
    typedef map<ULLNG, pIC_CDR>     CALL_MAP;   
    typedef struct {
        CALL_MAP    callMap;
        ULNG        Knt;         
        DBL         BurnRateSec; 
        DBL         DeciCents;   
        ULLNG       tThen;       
        DBL         OldKCIKey;   
    } CUST_SUM, *pCUST_SUM;
    typedef map<ULNG,CUST_SUM>  CUST_MAP, CUST_MAP;  
    typedef map<DBL,pCUST_SUM>  KCI_MAP;
    
  9. 使用 typedef 和 & 运算符传递对映射的引用

    ULNG DestroyCustomer_callMap(CUST_SUM Summary, CDR_MAP&amp; cdrMap, KCI_MAP&amp; kciMap)

  10. 对迭代器使用“auto”变量类型。编译器将从 for() 循环体的其余部分中指定的类型确定要使用哪种映射 typedef。它是如此的干净,几乎是魔法!

    for(auto itr = Summary.callMap.begin(); itr!= Summary.callMap.end(); ++itr) {

  11. 定义一些清单常量以使 .erase 和 .empty() 的返回更有意义。

    if(ERASE_SUCCESSFUL == cdrMap.erase (itr-&gt;second-&gt;iGUID)) {

  12. 鉴于“智能指针”实际上只是保持引用计数,请记住,您始终可以保持自己的引用计数,这可能以一种更清晰、更明显的方式。结合上面的#5和#10,你可以写出一些像这样漂亮干净的代码。

    #define Pear(x,y) std::make_pair(x,y) //  some macro magic
    
    auto res = pSumStruct->callMap.insert(Pear(pCDR->iGUID,pCDR));
    if ( ! res.second ) {
        pCDR->RefKnt=2;
    } else {
        pCDR->RefKnt=1;
        pSumStruct->Knt += 1;
    }
    
  13. 使用指针挂在映射节点上,该节点为自己分配一切,IE:没有用户指针指向用户 malloc()ed 对象,运行良好,可能更有效,并可用于变异根据我的经验,节点的数据没有副作用。

  14. 在同一主题上,可以非常有效地使用这样的指针来保存节点的状态,如上面的pThisCDRLeafData。将其传递给改变/更改特定节点数据的函数比传递对映射的引用更干净,并且返回节点pThisCDRLeafData 所指向的键所需的键。

  15. 迭代器不是魔法。当您在地图上导航以获取值时,它们既昂贵又缓慢。对于包含一百万个值的映射,您可以每秒大约 2000 万次基于键读取节点。使用迭代器可能会慢 1000 倍。

我认为现在差不多涵盖了它。如果有任何变化或有其他见解要分享,将会更新。我特别喜欢将 STL 与 C 代码一起使用。 IE:在任何地方都看不到一堂课。它们只是在我工作的环境中没有意义,这不是问题。祝你好运。

【讨论】:

  • 虽然有点折衷,但让 Map 分配它自己的数据而不是保存 malloc() 返回的指针也可以提高内存效率,因为你的 malloc() 和保存数据所需的 Map 的 malloc 大小将相同,从而节省了现在冗余指针的内存需求。 64 位指针增加了很多存储空间。这与 Map/Tree 的内部节点分配空间来存储它们永远不会存储的东西进行权衡 - 尽管它可以防止堆碎片,因为在添加或删除节点时所有 malloc() 大小相同。
  • 您可能会添加一个,是使用 malloc() 而不是 new(),因为在 memcpy 的过程中使用 new() 分配和 memset() 内存是没有意义的() 将数据放入该新存储中。这完全浪费了初始化存储所需的任何时间。如果要出于调试目的执行此操作,请使用 calloc()。 STL 在内部使用 malloc() 和 free(),因此请接受提示并使用它运行。
【解决方案2】:

任何容器都存储你的对象类型并调用相应的构造函数:每个节点的内部代码可能类似于:

__NodePtr
{
    *next;
    __Ty    Val;
}

当你分配它时,它是通过基于类型构造 val 然后链接来实现的。类似于:

_Ty _Val = _Ty();
_Myhead = _Buynode();
_Construct_n(_Count, _Val);

当你删除它时,它会调用相应的析构函数。

当您存储引用(指针)时,它不会调用任何构造函数,也不会破坏。

【讨论】:

    【解决方案3】:

    std::map 不管理指针值所指向的内存——这取决于你自己。如果您不想使用智能指针,您可以编写一个通用的 free & clear 函数,如下所示:

    template <typename M> void FreeClear( M & amap ) 
        for ( typename M::iterator it = amap.begin(); it != amap.end(); ++it ) {
            delete it->second;
        }
        amap.clear();
    }
    

    并使用它:

    std::map< int, A * > my_map;
    // populate
    FreeClear( my_map )
    

    ;

    【讨论】:

      【解决方案4】:

      当您释放一块堆内存时,其内容不会归零。它们仅可用于再次分配。当然你应该考虑内存不可访问,因为访问未分配内存的影响是不确定的。

      实际上阻止对内存页面的访问发生在较低级别,而标准库不会这样做。

      用new分配内存时,需要自己删除,除非使用智能指针。

      【讨论】:

        【解决方案5】:

        这是因为map.clear() 调用了映射中包含的数据的析构函数,在您的情况下,是指向a 的指针。而这无济于事。

        您可能希望将某种smart pointer 放入映射中,以便自动回收a 占用的内存。

        顺便说一句,您为什么将模板参数放在对make_pair 的调用中?模板参数推导在这里应该做得很好。

        【讨论】:

        • 所以如果我不使用任何类型的智能指针类,我是否需要遍历地图并手动delete 每个元素?之后如何清除地图?我的意思是,clear() 将尝试调用已删除元素的析构函数。
        • 只需删除所有指针,然后调用 clear()。正如 jpalecek 告诉你的,调用指针的析构函数(这与调用它指向的对象的析构函数完全不同)什么都不做。
        • 澄清一下:如果你将实际对象存储在地图中,它的析构函数将被调用。但是如果你存储指针(任何类型的指针),map 只会知道它有一堆无意义的指针,并将它们本质上视为:表示内存地址的整数。
        • 谢谢,马克。我现在知道了。在我的代码 sn-p 上面 struct A does 的析构函数被调用。 IE。元素x 设置为0。我担心如果我删除struct A map.clear() 的这个实例会再次尝试调用析构函数。
        • sneg-vx:这很奇怪。我用 gcc 4.3 试了一下,在输出中得到了 5 两次,所以没有调用析构函数(正如标准所说)。
        【解决方案6】:

        如果您将指针存储在地图(或列表或类似的东西)上,您负责删除指针,因为地图不知道它们是否是用 new 创建的, 或不。如果不使用指针,clear 函数只会调用析构函数。

        哦,还有一件事:调用析构函数(甚至调用删除)并不意味着不能再访问内存。这仅意味着如果您这样做,您将访问垃圾。

        【讨论】:

        • 这只是意味着您可能访问垃圾,但有时您访问的区域还没有变成垃圾,所以它似乎工作了一段时间。这就是为什么“但它有效,所以我可以摆脱它”是完全错误的。
        猜你喜欢
        • 1970-01-01
        • 1970-01-01
        • 2013-10-11
        • 2021-06-09
        • 1970-01-01
        • 2013-04-12
        • 2020-12-28
        • 1970-01-01
        • 2023-03-29
        相关资源
        最近更新 更多