C ++ 0x unique_ptr заменяет scoped_ptr на владение?

IMO лучше использовать unique_ptr, поскольку он предоставляет дополнительную функцию: семантику перемещения. то есть вы можете написать конструктор перемещения и т. д. для своего класса, в отличие от scoped_ptr. Кроме того, с unique_ptr не связаны накладные расходы, как в случае с scoped_ptr, так что это превосходное средство. Решение о перезаписи, конечно, зависит от вас, если вам не нужна семантика перемещения, тогда нет смысла перезаписывать. Не забывайте, что unique_ptr из стандартной библиотеки, поэтому он должен быть обеспечен любой совместимой реализацией C ++ 0x (когда, конечно, это станет реальностью :)!

Я не могу согласиться с Арак в одном вопросе о превосходстве. Нет такого понятия, как лучший выбор между ними, поскольку это часто зависит от использования. Это все равно что сказать, что SmartCar превосходит пикап во всех сферах применения, потому что он легче и быстрее. На самом деле, иногда вам нужен грузовик, а иногда нет. Ваш выбор указателя должен основываться на том, что вам нужно.

В scoped_ptr хорошо то, что он повышает уровень безопасности. Используя scoped_ptr, вы подтверждаете, что созданная память будет существовать только для этой области и не более того, таким образом вы получаете защиту во время компиляции от попыток ее перемещения или передачи.

Итак, если вы хотите создать что-то, но ограничить его объем, используйте scoped_ptr. Если вы хотите что-то создать и право собственности может быть перемещено, используйте unique_ptr. Если вы хотите что-то создать и поделиться этим указателем и очисткой, когда все ссылки исчезнут, используйте shared_ptr.

Изменить: мой плохой, вам нужно написать move(p) внутри инициализатора. std::move рассматривает все, что было дано, как ссылку на rvalue, и в вашем случае, даже если ваш аргумент является ссылкой rvalue на что-то, передача его чему-то другому (например, конструктору p_) передаст ссылку lvalue, а не ссылку rvalue по умолчанию.

Комментарий Per Karu также добавил необходимые включения, чтобы сделать мой код компилируемым.

Например:

#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 { // takes ownership A(unique_ptr

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

unique_ptr<P> p_;

};