Question

我在重构使用unique_ptrs的std :: vector的类时遇到了一些麻烦。我目前有一个类似于以下的课程：

class DataItemA
{
  // various data members
};

class DataItemB
{
  // various data members
};

class PointerOwner
{
public:
  PointerOwner();
  ~PointerOwner();

  void ComplexCalculationOnItemA()
  {
    for (auto itr = aItemsIOwn.begin(); itr != aItemsIOwn.end(); ++itr)
    {
      DataItemA& itemA= (**itr);

      // complex calculations that also reference DataItemB items
    }
  } 

  // methods to add / remove items from the collections
private:
  // This class owns the DataItems and control their lifetime.
  // The objects cannot live outside of this instance.
  std::vector<std::unique_ptr<DataItemA>> aItemsIOwn;
  std::vector<std::unique_ptr<DataItemB>> bItemsIOwn;
};

我正在重构类以将复杂计算提取到另一个类，并且不确定如何将unique_ptrs的向量传递给另一个类并且明确地“声明”计算不拥有指针。是否合理：

class ComplexItemAProcessor
{
  ComplexItemAProcessor(const std::vector<std::unique_ptr<DataItemA>>& itemsToProcess)
  {
    // can I store the itemsToProcess in a member variable
  }

  SomeReturnType runCalcuation() {}

private:

  // store the reference to calculation
}

或者这可以做得更好：

class ComplexItemAProcessor
{
  ComplexItemAProcessor()
  {

  }

  SomeReturnType runCalcuation(const std::vector<std::unique_ptr<DataItemA>>& itemsToProcess)
  {
    // process the collection as per original class
  }
}

ComplexItemAProcessor的生命周期将限于原始方法的范围。

class PointerOwner
{
public:
  PointerOwner();
  ~PointerOwner();

  ComplexCalculationOnItemA()
  {
    ComplexItemAProcessor processor; /** ? pass here **/

    SomeReturnType result = processor.runCalcuation(/* ? pass here */);
  } 
private:
  // This class owns the DataItems and control their lifetime.
  // The objects cannot live outside of this instance.
  std::vector<std::unique_ptr<DataItemA>> aItemsIOwn;
  std::vector<std::unique_ptr<DataItemB>> bItemsIOwn;
};

这些中的任何一个都比另一个好吗？对我来说感觉不对，但这可能是我对智能指针的有限经验。另一个类是否有另一种方法来处理向量而不转移所有权？

我认为我不需要shared_ptrs，因为PointerOwner是唯一的所有者。

使用std :: vector <std :: unique_ptr>＆gt;到另一个类/函数</std :: unique_ptr>

0 个答案: