unique_ptr 獨占所指向的對象, 同一時刻只能有一個 unique_ptr 指向給定對象(通過禁止拷貝語義, 只有移動語義來實現), 定義於 memory (非memory.h)中, 命名空間為 std.
標准庫早期版本中定義了 auto_ptr, 它具有 unique_ptr 的部分特征, 但不是全部, 例如, 不能在容器中保存 auto_ptr, 也不能從函數中返回 auto_ptr.
基於這些原因, 應該盡量使用 unique_ptr, 而不是 auto_ptr, 使用 unique_ptr 替換 auto_ptr.
基本用法:
std::unique_ptr<A> up1;
up1.reset(new A(3));
std::unique_ptr<A> up2(new A(4));
A* p = up2.release();
delete p;
std::unique_ptr<A> up3(new A(11));
std::unique_ptr<A> up4 = std::move(up3);
up4 = nullptr;//顯式銷毀所指對象，同時智能指針變為空指針。與u_s2.reset()等價
(1) get 獲得內部對象的指針, 由於已經重載了()方法, 因此和直接使用對象是一樣的.如 unique_ptr<int> sp(new int(1)); sp 與 sp.get()是等價的
(2) release 放棄內部對象的所有權，將內部指針置為空, 返回所內部對象的指針, 此指針需要手動釋放
(3) reset 銷毀內部對象並接受新的對象的所有權(如果使用缺省參數的話，也就是沒有任何對象的所有權, 此時僅將內部對象釋放, 並置為空)
(4) swap 交換兩個 shared_ptr 對象(即交換所擁有的對象)
std::move(up) 所有權轉移(通過移動語義), up所有權轉移後，變成“空指針” (up 的定義為 std::unique_ptr<Ty> up)
unique_ptr 不支持拷貝和賦值.
std::unique_ptr<A> up1(new A(5));
std::unique_ptr<A> up2(up1); // 錯誤, unique_ptr 不支持拷貝
std::unique_ptr<A> up2 = up1; // 錯誤, unique_ptr 不支持賦值
雖然 unique_ptr 不支持拷貝和賦值, 但是我們可以調用 release 或 reset 將指針的所有權從一個(非 const) unique_ptr 轉移到另一個.
std::unique_ptr<int> up1(new int(1));
std::unique_ptr<int> up2(up1.release());
雖然 unique_ptr 不支持拷貝, 但是可以從函數中返回, 甚至返回局部對象. 如下面的代碼, 編譯器知道要返回的對象即將被銷毀, 因此執行一種特殊的"拷貝":
template <class Ty>
std::unique_ptr<Ty> Clone(const Ty& obj)
{
return std::unique_ptr<Ty>(new Ty(obj));
}
template <class Ty>
std::unique_ptr<Ty> Clone(const Ty& obj)
{
std::unique_ptr<Ty> temp = std::unique_ptr<Ty>(new Ty(obj));
return temp;
}
std::unique_ptr<A[]> ups(new A[10]);
printf("sizeof(ups) = %d\n", sizeof(ups));
for (int i = 0; i < 10; i++)
{
ups[i] = i;
printf("ups[i] = %d\n", ups[i]);
}
重載一個 unique_ptr 的刪除器會影響到 unique_ptr 類型以及如何構造該類的對象, 必須在尖括號中指定刪除器類型. 然後在創建或 reset 時提供刪除器對象.
unique_ptr<T, D> up;
可以使用 decltype 來指明函數指針的類型.
class CConnnect
{
void Disconnect() { PRINT_FUN(); }
};
void Deleter(CConnnect* obj)
{
obj->Disconnect(); // 做其它釋放或斷開連接等工作
delete obj; // 刪除對象指針
}
std::unique_ptr<CConnnect, decltype(Deleter)*> up(new CConnnect, Deleter);
另一種用法:
class Deleter
{
public:
void operator() (CConnnect* obj)
{
PRINT_FUN();
delete obj;
}
};
std::unique_ptr<CConnnect, Deleter> up1(new CConnnect);
std::unique_ptr<CConnnect, Deleter> up2(new CConnnect, up1.get_deleter());
VC中的源碼實現
template<class _Ty,
class _Dx> // = default_delete<_Ty>
class unique_ptr
: public _Unique_ptr_base<_Ty, _Dx,
tr1::is_empty<_Dx>::value
|| tr1::is_same<default_delete<_Ty>, _Dx>::value>
{ // non-copyable pointer to an object
public:
typedef unique_ptr<_Ty, _Dx> _Myt;
typedef _Unique_ptr_base<_Ty, _Dx,
tr1::is_empty<_Dx>::value
|| tr1::is_same<default_delete<_Ty>, _Dx>::value> _Mybase;
typedef typename _Mybase::pointer pointer;
typedef _Ty element_type;
typedef _Dx deleter_type;
unique_ptr()
: _Mybase(pointer(), _Dx())
{ // default construct
static_assert(!is_pointer<_Dx>::value,
"unique_ptr constructed with null deleter pointer");
}
#if defined(_NATIVE_NULLPTR_SUPPORTED) \
&& !defined(_DO_NOT_USE_NULLPTR_IN_STL)
unique_ptr(_STD nullptr_t)
: _Mybase(pointer(), _Dx())
{ // null pointer construct
static_assert(!is_pointer<_Dx>::value,
"unique_ptr constructed with null deleter pointer");
}
_Myt& operator=(_STD nullptr_t)
{ // assign a null pointer
reset();
return (*this);
}
#endif /* defined(_NATIVE_NULLPTR_SUPPORTED) etc. */
explicit unique_ptr(pointer _Ptr)
: _Mybase(_Ptr, _Dx())
{ // construct with pointer
static_assert(!is_pointer<_Dx>::value,
"unique_ptr constructed with null deleter pointer");
}
unique_ptr(pointer _Ptr,
typename _If<tr1::is_reference<_Dx>::value, _Dx,
const typename tr1::remove_reference<_Dx>::type&>::_Type _Dt)
: _Mybase(_Ptr, _Dt)
{ // construct with pointer and (maybe const) deleter&
}
unique_ptr(pointer _Ptr, typename tr1::remove_reference<_Dx>::type&& _Dt)
: _Mybase(_Ptr, _STD move(_Dt))
{ // construct by moving deleter
// static_assert(!tr1::is_reference<_Dx>::value,
// "unique_ptr constructed with reference to rvalue deleter");
}
unique_ptr(unique_ptr&& _Right)
: _Mybase(_Right.release(),
_STD forward<_Dx>(_Right.get_deleter()))
{ // construct by moving _Right
}
template<class _Ty2,
class _Dx2>
unique_ptr(unique_ptr<_Ty2, _Dx2>&& _Right)
: _Mybase(_Right.release(),
_STD forward<_Dx2>(_Right.get_deleter()))
{ // construct by moving _Right
}
template<class _Ty2,
class _Dx2>
_Myt& operator=(unique_ptr<_Ty2, _Dx2>&& _Right)
{ // assign by moving _Right
reset(_Right.release());
this->get_deleter() = _STD move(_Right.get_deleter());
return (*this);
}
_Myt& operator=(_Myt&& _Right)
{ // assign by moving _Right
if (this != &_Right)
{ // different, do the move
reset(_Right.release());
this->get_deleter() = _STD move(_Right.get_deleter());
}
return (*this);
}
void swap(_Myt&& _Right)
{ // swap elements
if (this != &_Right)
{ // different, do the swap
_Swap_adl(this->_Myptr, _Right._Myptr);
_Swap_adl(this->get_deleter(),
_Right.get_deleter());
}
}
void swap(_Myt& _Right)
{ // swap elements
_Swap_adl(this->_Myptr, _Right._Myptr);
_Swap_adl(this->get_deleter(),
_Right.get_deleter());
}
~unique_ptr()
{ // destroy the object
_Delete();
}
typename tr1::add_reference<_Ty>::type operator*() const
{ // return reference to object
return (*this->_Myptr);
}
pointer operator->() const
{ // return pointer to class object
return (&**this);
}
pointer get() const
{ // return pointer to object
return (this->_Myptr);
}
_OPERATOR_BOOL() const
{ // test for non-null pointer
return (this->_Myptr != pointer() ? _CONVERTIBLE_TO_TRUE : 0);
}
pointer release()
{ // yield ownership of pointer
pointer _Ans = this->_Myptr;
this->_Myptr = pointer();
return (_Ans);
}
void reset(pointer _Ptr = pointer())
{ // establish new pointer
if (_Ptr != this->_Myptr)
{ // different pointer, delete old and reassign
_Delete();
this->_Myptr = _Ptr;
}
}
private:
void _Delete()
{ // delete the pointer
if (this->_Myptr != pointer())
this->get_deleter()(this->_Myptr);
}
unique_ptr(const _Myt&); // not defined
template<class _Ty2,
class _Dx2>
unique_ptr(const unique_ptr<_Ty2, _Dx2>&); // not defined
_Myt& operator=(const _Myt&); // not defined
template<class _Ty2,
class _Dx2>
_Myt& operator=(const unique_ptr<_Ty2, _Dx2>&); // not defined
};
