如何在必须复制构造的类中使用 std::auto_ptr ？

Question

我有一个包含 std::auto_ptr 成员的类 foo，我想复制该成员，但这似乎是不允许的。 任务中也有类似的事情。 请参阅以下示例：

struct foo
{
private:
    int _a;
    std::string _b;
    std::auto_ptr< bar > _c;

public:
    foo(const foo& rhs)
        :   _a(rhs._a)
        ,   _b(rhs._b)

        ,   _c(rhs._c)
                // error: Cannot mutate rhs._c to give up ownership - D'Oh!
    {
    }

    foo& operator=(const foo& rhs)
    {
         _a = rhs._a;
         _b = rhs._b;

         _c = rhs._c;
             // error: Same problem again.
    }
};

我可以将 _c 声明为 mutable 但我不确定这是否正确。 有人有更好的解决方案吗？

编辑

好的，我没有得到我所期待的答案，所以我会更具体地说明这个问题。

• foo 类型的对象在堆栈上创建，并按值传递到容器类（不是 stl），然后超出范围。 我对容器代码没有任何控制权。 （它实际上是一个活动队列实现，存在错误。）
• bar 类是一个相当重量级的解析器。 它在new和delete上的性能非常差，所以即使它是可复制构造的，它也会太昂贵。
• 我们可以保证，当创建 bar 对象时，一次只需要在 1 个位置拥有它。 在这种情况下，它在线程之间传递，并在事务完成时被删除。 这就是为什么我希望使用 std::autp_ptr 。
• 我非常愿意考虑增强智能指针，但我希望如果有替代方案的话能够保证这种唯一性。

Answer 1

您可能想尝试以下代码：（

    foo(const foo& rhs)
        :   _a(rhs._a)
        ,   _b(rhs._b)
        ,   _c(_rhs._c.get() ? new bar(*_rhs._c.get()) : 0)
    {
    }

赋值运算符类似。）

但是，只有当 bar 是可复制构造的并且确实满足您的要求时，这才有效。 问题是，两个 foo 对象（_rhs 和构造对象）在 _c 中将具有不同的指针。

如果您希望它们共享指针，则不得使用 auto_ptr，因为它不支持共享所有权。 在这种情况下请考虑使用 shared_ptr< /code> 来自 Boost.SmartPtr 例如（将包含在新的 C++ 标准中）。 或者任何其他共享指针实现，因为这是一个常见的概念，有很多实现可用。

Answer 2

正如您所发现的，您无法像这样复制 std::auto_ptr 。 复制之后谁拥有所指向的对象？ 相反，您应该使用引用计数智能指针。 Boost 库 有一个 shared_ptr 您可以使用。

Answer 3

首先，我会避免使用 auto_ptr

所有权转移在某些情况下很好，但我发现这种情况很少见，而且“成熟的”智能指针库现在很容易获得。 （IIRC auto_ptr 是一种折衷方案，在标准库中包含至少一个示例，而不会出现良好实现所需的延迟）。

参见此处的示例
或此处

决定语义
foo 的副本是否应该包含对同一 bar 实例的引用？ 在这种情况下，请使用 boost::shared_ptr或 (boost::intrusive_ptr) 或类似的库。

或者应该创建深拷贝？
（有时可能需要这样做，例如当具有延迟创建的状态时）。 我不知道这个概念的任何标准实现，但是构建类似于现有智能指针的东西并不复杂。

   // roughly, incomplete, probably broken:
   template <typename T>
   class deep_copy_ptr
   {
      T * p;
     public:
      deep_copy_ptr()  : p(0) {}
      deep_copy_ptr(T * p_)  : p(p_) {}
      deep_copy_ptr(deep_copy_ptr<T> const & rhs)  
      {
        p = rhs.p ? new T(*rhs.p) : 0;
      }
      deep_copy_ptr<T> & operator=(deep_copy_ptr<T> const & rhs)
      {
         if (p != rhs.p)
         {
           deep_copy_ptr<T> copy(rhs);
           swap(copy);
         }
      }
      // ...
   }

Answer 4

std::auto_ptr 是管理 C++ 中动态对象的好工具，但为了有效地使用它，了解 auto_ptr 的工作原理非常重要。 本文解释了应使用此智能指针的原因、时间和地点。

对于您的情况，首先您应该决定要如何处理 auto_ptr 中的对象。 应该克隆还是共享？

如果应该克隆它，请确保它有一个复制构造函数，然后创建一个新的 auto_ptr，其中包含对象的副本，请参阅 Adam Badura 的回答。

如果需要共享，您应该使用 boost::shared_ptr 正如Martin Liversage建议的那样。

Answer 5

如果我有一个包含 auto_ptr 的类，并且想要深度复制语义，我通常只对具有虚拟复制运算符（即clone()）的类执行此操作。

然后，在复制构造函数中，我将 auto_ptr 初始化为另一个的 clone() ； 例如，

class Foo
{
   public:
      Foo(const Foo& rhs) : m_ptr(rhs.m_ptr->clone());
   private:
      std::auto_ptr<T> m_ptr;
};

clone() 通常按如下方式实现：

class T
{
   std::auto_ptr<T> clone() const
   {
      return std::auto_ptr<T>(new T(*this));
   }
};

我们强加 T 是可克隆的条件，但该条件本质上是通过具有带有 auto_ptr 成员的可复制类来强加的。

Answer 6

auto_ptr 的整体思想是所引用的对象只有一个所有者。 这意味着您无法在不删除原始所有权的情况下复制指针。

由于您无法复制它，因此您也无法复制包含 auto_ptr 的对象。

您可以尝试使用移动语义，例如使用 std::swap 而不是复制。

Answer 7

我的第一选择是在这种情况下完全避免 auto_ptr 。 但如果我陷入困境，我可能会尝试在 _c 的声明中使用关键字 mutable - 这将允许它甚至可以从 const 引用进行修改。

Answer 8

进行编辑后，您似乎想要转让所有权语义。

在这种情况下，您需要让复制构造函数和赋值运算符接受对其参数的非常量引用，并在那里执行初始化/赋值。

Answer 9

您不能在涉及 auto_ptr 的复制构造函数或赋值运算符中使用 const 引用。 删除常量。 换句话说，像

foo(foo & rhs);
foo & operator=(foo & rhs);

这些形式这样的使用声明在标准中明确提到，主要是在第 12.8 节中。 它们应该可用于任何符合标准的实施。 事实上，12.8 的第 5 和第 10 段表示，如果任何成员需要，隐式定义的复制构造函数和赋值运算符（分别）将采用非常量引用。