0

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

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); //使用一段时间后，客户端应该删除这个指针 delete aPointer;

然而，RALL 需要基本删除本身，无需客户的帮助。所以我正在尝试修改代码。我所做的是：

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 保留为静态方法，因为我的优化不应该修改太多的客户端代码）

4

2 回答 2

2

为什么这么复杂！？

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< SomeClass > 也可以

于 2013-12-16T21:31:17.973 回答
0

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

于 2013-12-16T21:18:58.020 回答