Unique pointer：
　　Manages the storage of a pointer, providing a limited garbage-collection facility, with little to no overhead over built-in pointers (depending on the deleter used).
　　 These objects have the ability of taking ownership of a pointer: once they take ownership they manage the pointed object by becoming responsible for its deletion at some point.
　　 unique_ptr objects automatically delete the object they manage (using a deleter) as soon as they themselves are destroyed, or as soon as their value changes either by an assignment operation or by an explicit call to unique_ptr::reset.
　　 unique_ptr objects own their pointer uniquely: no other facility shall take care of deleting the object, and thus no other managed pointer should point to its managed object, since as soon as they have to, unique_ptr objects delete their managed object without taking into account whether other pointers still point to the same object or not, and thus leaving any other pointers that point there as pointing to an invalid location.

　　 A unique_ptr object has two components:
　　• a stored pointer: the pointer to the object it manages. This is set on construction, can be altered by anassignment operation or by calling member reset, and can be individually accessed for reading using members get or release.
　　• a stored deleter: a callable object that takes an argument of the same type as the stored pointer and is called to delete the managed object. It is set on construction, can be altered by an assignment operation, and can be individually accessed using member get_deleter.

　　unique_ptr objects replicate a limited pointer functionality by providing access to its managed object through operators * and -> (for individual objects), or operator [] (for array objects). For safety reasons, they do not support pointer arithmetics, and only support move assignment (disabling copy assignments).

　　來看程式碼：

template <typename _Tp, typename _Tp_Deleter = default_delete<_Tp> > 
  class unique_ptr
  {
  public:
    typedef _Tp*               pointer;
    typedef _Tp                element_type;      
    typedef _Tp_Deleter        deleter_type;

    // Constructors.
    unique_ptr()
    : _M_t(pointer(), deleter_type())
    { static_assert(!std::is_pointer<deleter_type>::value,
            "constructed with null function pointer deleter"); }

    explicit
    unique_ptr(pointer __p)
    : _M_t(__p, deleter_type())
    { static_assert(!std::is_pointer<deleter_type>::value,
           "constructed with null function pointer deleter"); }

    unique_ptr(pointer __p,
        typename std::conditional<std::is_reference<deleter_type>::value, 
          deleter_type, const deleter_type&>::type __d)
    : _M_t(__p, __d) { }

    unique_ptr(pointer __p,
        typename std::remove_reference<deleter_type>::type&& __d)
    : _M_t(std::move(__p), std::move(__d))
    { static_assert(!std::is_reference<deleter_type>::value, 
            "rvalue deleter bound to reference"); }

    // Move constructors.
    unique_ptr(unique_ptr&& __u) 
    : _M_t(__u.release(), std::forward<deleter_type>(__u.get_deleter())) { }

    template<typename _Up, typename _Up_Deleter> 
      unique_ptr(unique_ptr<_Up, _Up_Deleter>&& __u) 
      : _M_t(__u.release(), std::forward<deleter_type>(__u.get_deleter()))
  { }

    // Destructor.
    ~unique_ptr() { reset(); }

    // Assignment.
    unique_ptr&
    operator=(unique_ptr&& __u)
    { 
      reset(__u.release()); 
      get_deleter() = std::move(__u.get_deleter()); 
      return *this;
    }

    template<typename _Up, typename _Up_Deleter> 
      unique_ptr&
      operator=(unique_ptr<_Up, _Up_Deleter>&& __u)
  {
        reset(__u.release()); 
        get_deleter() = std::move(__u.get_deleter()); 
        return *this;
      }

    unique_ptr&
    operator=(__unspecified_pointer_type) 
    {
  reset();
  return *this;
    }

    // Observers.
    typename std::add_lvalue_reference<element_type>::type operator*() const
    {
  _GLIBCXX_DEBUG_ASSERT(get() != 0);
  return *get();
    }

    pointer
    operator->() const
    {
  _GLIBCXX_DEBUG_ASSERT(get() != 0);
  return get();
    }

    pointer
    get() const
    { return std::get<0>(_M_t); }

    typename std::add_lvalue_reference<deleter_type>::type
    get_deleter()
    { return std::get<1>(_M_t); }

    typename std::add_lvalue_reference<
        typename std::add_const<deleter_type>::type
            >::type
    get_deleter() const
    { return std::get<1>(_M_t); }

    operator __unspecified_bool_type () const
    { return get() == 0 ? 0 : &unique_ptr::_M_t; }

    // Modifiers.
    pointer
    release() 
    {
  pointer __p = get();
  std::get<0>(_M_t) = 0;
  return __p;
    }

    void
    reset(pointer __p = pointer())
    {
  if (__p != get())
    {
      get_deleter()(get());
      std::get<0>(_M_t) = __p;
    }
    }

    void
    swap(unique_ptr&& __u)
    {
  using std::swap;
  swap(_M_t, __u._M_t);
    }

    // Disable copy from lvalue.
    unique_ptr(const unique_ptr&) = delete;

    template<typename _Up, typename _Up_Deleter> 
      unique_ptr(const unique_ptr<_Up, _Up_Deleter>&) = delete;

    unique_ptr& operator=(const unique_ptr&) = delete;

    template<typename _Up, typename _Up_Deleter> 
      unique_ptr& operator=(const unique_ptr<_Up, _Up_Deleter>&) = delete;

  private:
    __tuple_type _M_t;
};

　　上面的程式碼禁用了拷貝構造和賦值操作，所以在使用時必須強調使用move語義或右值引用，否則會報錯。

總結：
　　unique_ptr是一個獨享所有權的智慧指標，它提供了一種嚴格語義上的所有權，包括：
　　1、擁有它所指向的物件。
　　2、無法進行復制構造，也無法進行復制賦值操作。也就是說，我們無法得到指向同一個物件的兩個unique_ptr。但是可以進行移動構造和移動賦值操作。
　　3、儲存指向某個物件的指標，當它本身被刪除釋放的時候（比如，離開了某個作用域），會使用給定的刪除器釋放它指向的物件。
　　使用unique_ptr，可以實現以下功能，包括：
　　1、為動態申請的記憶體提供異常安全。
　　2、將動態申請記憶體的所有權傳遞給某個函式。
　　3、從某個函式返回動態申請記憶體的所有權。
　　4、在容器中儲存指標。
　　5、所有auto_ptr應該具有的（但無法在C++ 03中實現的）功能
　　至於unique_ptr和auto_ptr區別主要是在語義上，而且在必須交換控制權的情況下(非右值)，unique_ptr會顯式的要求執行move操作，否則它會對使用者提出警示，這避免一些無心的拷貝發生。第二個區別是unique_ptr更加的高效，因為他使用的是右值引用，而不是拷貝構造。　
　　auto_ptr解構函式只是單純的delete掉raw指標，而unique_ptr則可以定製自己的deleter，來指定unique_ptr析構時需要做哪些工作。

// unique_ptr destructor example
#include <iostream>
#include <memory>

int main () {
  auto deleter = [](int*p){
    delete p;
    std::cout << "[deleter called]\n";
  };

  std::unique_ptr<int,decltype(deleter)> foo (new int,deleter);

  std::cout << "foo " << (foo?"is not":"is") << " empty\n";

  return 0;                        // [deleter called]
}
Output:
foo is not empty
[deleter called]

　　c++11中引入的move語義使得unique_ptr可以存放到容器中，參考這篇文章(http://www.th7.cn/Program/cp/201408/267890.shtml)。使用move就表示放棄對該物件的所有權，但並不對raw指標進行釋放。經過move函式呼叫後，失去了對raw指標的所有權，並未釋放raw指標，之後如果誤用了原來的unique_ptr，會導致undefine行為。