Question

我正在尝试优化项目的部分代码。有一些背景可以显示：

Class Basic
{
  type* _shareResource;
  virtual Basic(){};
  virtual ~Basic(){};
  virtual void initialResource() = 0;
  virtual void deleteResource() = 0;
  virtual void ownmethod() = 0;
  static Basic* createChild(int condition);
}
Basic* Basic::createChild(int condtion)
{
   Basic* pointer;
   if (condition ==  1)
       pointer = new ChildA();
   else 
       pointer = new ChildB();  
   return pointer; 
}


Class ChildA::public Basic
{
  void initialResource(){ allocate memory for _shareResource;}
  void deleteResource(){ delete _shareResource; _shareResource = NULL;}
  ChildA(){ initialResource(); }
  ~ChildA(){ deleteResource(); }
  virtual ownmethod() {// child A method}

}

Class ChildB::public ChildA
{
  void initialResource(){ allocate memory for _shareResource;}
  void deleteResource(){ delete _shareResource; _shareResource = NULL;}
  ChildB(){ initialResource(); }
  ~ChildB(){ deleteResource(); }
  virtual ownmethod(){// child B method}
}

所以，当我使用Basic :: createChild（）作为客户端时： Basic * aPointer = CreateChild（1）; //在一些用法之后，客户端应删除此ponter 删除aPointer;

但是，RALL需要在没有客户端帮助的情况下进行Basic删除。所以我试图修改代码。我做的是：

boost::share_ptr<Basic> Basic::createChild(int condtion)
{
   boost::share_ptr<Basic> pointer;
   if (condition ==  1)
       pointer = boost::share_ptr<ChildA>(new ChildA());
   else 
       pointer = boost::share_ptr<ChildA>(new ChildB());
   return pointer   
}

但是我把核心转储作为内存泄漏，我从子类的deleteResource（）检查了它，但我不知道为什么。

您能否帮我解释核心转储或为遵循RALL原则提供更好的解决方案？非常感谢。（我更喜欢将createChild保留为静态方法，因为我的优化不应该修改过多的客户端代码）

Answer 1

为什么这么复杂！？

class Shared
{
   protected:
   struct Implementation
   {
       virtual ~Implementation() {}
   };

   protected:
   Shared(Implementation* p)
   : m_self(p)
   {}

   private:
   std/boost::shared_ptr<Implementation> m_self;
}

使用从Shared :: Implementation

派生的嵌套类派生类

然而，传递std / boost :: shared_ptr＆lt; SomeClass＆gt;也会这样做

Answer 2

声明Basic虚拟的析构函数。很可能没有调用派生类析构函数。

“资源获取是初始化”用于解决内存泄漏问题

2 个答案: