C++0x unique_ptr 取代了scoped_ptr 取得所有权？

Question

我曾经写过这样的代码：

class P {};

class Q: public P {};

class A {
    // takes ownership
    A(P* p): p_(p) {}

    scoped_ptr<P> p_;
};

A a(new Q);

使用C++0x，我应该将A类重写为：

class A {
    // takes ownership
    A(unique_ptr<P>&& p): p_(p) {}

    unique_ptr<P> p_;
};

Answer 1

我已经对 comonad 的答案投了赞成票，但有一个警告：

每当你想明确地
禁止移动语义，使用scoped_ptr const unique_ptr。

我还没有遇到过 const std::unique_ptr 不如 boost::scoped_ptr 的任何用例。不过，我对这个主题的教育持开放态度。

编辑：

这是 boost::scoped_ptr 的一个用例，我认为应该失败，但没有。 std::unique_ptr 确实会失败：

#include <iostream>

#ifdef USE_UNIQUEPTR

#include <memory>
typedef std::unique_ptr<int> P;

#else  // USE_UNIQUEPTR

#include <boost/scoped_ptr.hpp>
typedef boost::scoped_ptr<int> P;

#endif  // USE_UNIQUEPTR

int main()
{
    P p1(new int(1));
    {
        // new scope
#ifdef USE_UNIQUEPTR
        const P p2(new int(2));
#else  // USE_UNIQUEPTR
        P p2(new int(2));
#endif  // USE_UNIQUEPTR
        swap(p1, p2);  // should fail!
    }
    std::cout << *p1 << '\n';
}

如果 boost::scoped_ptr 的承诺是其资源不会逃逸当前作用域，那么它就不太擅长保存该承诺作为 const std::unique_ptr 。如果我们想比较 const boost::scoped_ptr 和 const::std::unique_ptr，我必须问：出于什么目的？它们对我来说似乎是一样的，除了 const std::unique_ptr 允许自定义构造和销毁。

Answer 2

• auto_ptr 是一个带有复制和带有的指针> 移动语义和所有权（=自动删除）。
• unique_ptr 是 auto_ptr 没有复制，但有 移动 语义。

• scoped_ptr 是一个 auto_ptr 无复制和无移动语义。

  auto_ptr‍s 总是一个糟糕的选择——这是显而易见的。

  每当您想要明确拥有移动语义时，请使用unique_ptr。

  每当您想要明确禁止移动语义时，请使用scoped_ptr。

• 所有指针都允许交换语义，例如p.swap(q)。要禁止这些，请使用任何const …_ptr。

在某些情况下，您想要使用指向多个可互换对象之一的 scoped_ptr：由于缺乏移动语义，因此非常安全（相对于明显的错误），它不会意外由于意外移动而指向 null。值得一提的是：scoped_ptr‍仍然可以有效交换‍。为了使其可移动和/或可复制 - 但仍然具有这些交换语义 - 您可能需要考虑使用指向可交换的 scoped_ptr 的 shared_ptr （通过scoped_ptr： ：交换）对象。

有关更多详细信息，请参阅 stackoverflow:smart-pointers-boost-explained。

Answer 3

IMO 最好使用 unique_ptr 因为它提供了一个附加功能：移动语义。即，您可以为您的类编写移动构造函数等，这与 scoped_ptr 不同。此外，unique_ptr 不像 scoped_ptr 那样有与之相关的开销，因此它是一个优越的设施。当然，重写的决定取决于您，如果您不需要移动语义，那么重写就没有意义。不要忘记 unique_ptr 来自标准库，因此它必须与 C++0x 的任何兼容实现一起提供（当然当它成为现实时:)！

Answer 4

我不同意 AraK 的观点，认为其中一个更优越。两者之间不存在更好的选择，因为它通常取决于使用情况。这就像说 SmartCar 在所有用途上都优于皮卡车，因为它更轻、更快。事实上，有时您需要卡车，有时则不需要。您应该根据您的需要选择指针。

scoped_ptr 的好处是它增加了一定程度的安全性。通过使用scoped_ptr，您可以声明创建的内存仅适用于该范围，而不再存在，因此您可以获得编译时保护，防止尝试移动它或传输它。

因此，如果您想创建某些东西但限制其范围，请使用scoped_ptr。如果您想创建某些东西并拥有可移动的所有权，请使用 unique_ptr。如果您想创建一些东西并共享该指针并在所有引用都消失时进行清理，请使用shared_ptr。

Answer 5

编辑：我的错，您确实需要在初始化程序中编写 move(p) 。 std::move 将给定的任何内容视为右值引用，在您的情况下，即使您的参数是对某些内容的右值引用，也会将其传递给其他内容（例如 p_ 的构造函数）将传递左值引用，默认情况下绝不传递右值引用。

根据卡鲁的评论，还添加了必要的包含以使我的代码可编译。

例如：

#include <memory>
#include <cassert>
#include <vector>
using namespace std;

class A {};

class B {
public:
  void takeOwnershipOf(unique_ptr<A>&& rhs) {
    // We need to explicitly cast rhs to an rvalue when passing it to push_back
    // (otherwise it would be passed as an lvalue by default, no matter what
    // qualifier it has in the argument list).  When we do that, the move
    // constructor of unique_ptr will take ownership of the pointed-to value
    // inside rhs, thus making rhs point to nothing.
    owned_objects.push_back(std::move(rhs));
  }

private:
  vector<unique_ptr<A>> owned_objects;
};

int main() {
  unique_ptr<B> b(new B());
  // we don't need to use std::move here, because the argument is an rvalue,
  // so it will automatically be transformed into an rvalue reference.
  b->takeOwnershipOf( unique_ptr<A>(new A()) );

  unique_ptr<A> a (new A());
  // a points to something
  assert(a);
  // however, here a is an lvalue (it can be assigned to). Thus we must use
  // std::move to convert a into an rvalue reference.
  b->takeOwnershipOf( std::move(a) );
  // whatever a pointed to has now been moved; a doesn't own it anymore, so
  // a points to 0.
  assert(!a);
  return 0;
}

另外，在您原来的示例中，您应该像这样重写类 A：

class A {
// 取得所有权
A(unique_ptr

&& p): p_(std::move(p)) {}

unique_ptr<P> p_;

};