Smart Pointers
tips: vs raw pointers? is smart?
unique_ptr
single pointer template
template <typename _Tp, typename _Dp = default_delete<_Tp>>
class unique_ptr
arrays template
template<typename _Tp, typename _Dp>
class unique_ptr<_Tp[], _Dp>
no deleter ctor
template<typename _Del = _Dp, typename = _DeleterConstraint<_Del>>
explicit
unique_ptr(pointer __p) noexcept
: _M_t(__p)
{ }
__uniq_ptr_impl(pointer __p) : _M_t() { _M_ptr() = __p; }
lvalue deleter ctor
template<typename _Del = deleter_type,
typename = _Require<is_copy_constructible<_Del>>>
unique_ptr(pointer __p, const deleter_type& __d) noexcept
: _M_t(__p, __d) { }
rvalue deleter ctor
typename = _Require<is_move_constructible<_Del>>>
unique_ptr(pointer __p,
__enable_if_t<!is_lvalue_reference<_Del>::value,
_Del&&> __d) noexcept
: _M_t(__p, std::move(__d))
{ }
template<typename _Del>
__uniq_ptr_impl(pointer __p, _Del&& __d)
: _M_t(__p, std::forward<_Del>(__d)) { }
tuple<pointer, _Dp> _M_t;
dtor
~unique_ptr()
{
auto& __ptr = _M_t._M_ptr();
if (__ptr != nullptr)
get_deleter()(__ptr);
__ptr = pointer();
}
reset
void reset(nullptr_t = nullptr) noexcept
{
reset(pointer());
}
void reset(pointer __p = pointer()) noexcept
{
static_assert(__is_invocable<deleter_type&, pointer>::value,
"unique_ptr's deleter must be invocable with a pointer");
using std::swap;
swap(_M_t._M_ptr(), __p);
if (__p != pointer())
get_deleter()(std::move(__p));
}
swap
void swap(unique_ptr& __u) noexcept
{
using std::swap;
swap(_M_t, __u._M_t);
}
get
pointer& _M_ptr() { return std::get<0>(_M_t); }
pointer _M_ptr() const { return std::get<0>(_M_t); }
pointer get() const noexcept
{
return _M_t._M_ptr();
}
no lvalue copy
unique_ptr(const unique_ptr&) = delete;
unique_ptr& operator=(const unique_ptr&) = delete;
operator == ,*, &, !=…
template<typename _Tp, typename _Dp,typename _Up, typename _Ep>
inline bool
operator==(const unique_ptr<_Tp, _Dp>& __x,
const unique_ptr<_Up, _Ep>& __y)
{
return __x.get() == __y.get();
}
pointer operator->() const noexcept
{
_GLIBCXX_DEBUG_PEDASSERT(get() != pointer());
return get();
}
typename add_lvalue_reference<element_type>::type
operator*() const
{
__glibcxx_assert(get() != pointer());
return *get();
}
unique_ptr& operator=(unique_ptr&& __u) noexcept
{
reset(__u.release());
get_deleter() = std::forward<deleter_type>(__u.get_deleter());
return *this;
}
//创建一个指向 int 的空指针
std::unique_ptr<int> fPtr1;
std::unique_ptr<int> fPtr2(new int());
auto fPtr3 = std::make_unique<int>();
int main()
{
unique_ptr<int> pInt(new int(5));
// 转移所有权
unique_ptr<int> pInt2 = std::move(pInt);
//cout << *pInt << endl; // 出错，pInt 为空
cout << *pInt2 << endl;
unique_ptr<int> pInt3(std::move(pInt2));
}
share_ptr
ctor
constexpr __shared_ptr() noexcept
: _M_ptr(0), _M_refcount()
{ }
//shared_ptr
template<typename _Yp, typename = _SafeConv<_Yp>>
explicit __shared_ptr(_Yp* __p)
: _M_ptr(__p), _M_refcount(__p, typename is_array<_Tp>::type())
{
static_assert( !is_void<_Yp>::value, "incomplete type" );
static_assert( sizeof(_Yp) > 0, "incomplete type" );
_M_enable_shared_from_this_with(__p);
}
//shared_count
template<typename _Ptr>
__shared_count(_Ptr __p, /* is_array = */ false_type)
: __shared_count(__p)
{ }
template<typename _Ptr>
__shared_count(_Ptr __p, /* is_array = */ true_type)
: __shared_count(__p, __sp_array_delete{}, allocator<void>())
{ }
template<typename _Ptr>
explicit __shared_count(_Ptr __p) : _M_pi(0)
{
__try
{
_M_pi = new _Sp_counted_ptr<_Ptr, _Lp>(__p);
}
__catch(...)
{
delete __p;
__throw_exception_again;
}
}
explicit _Sp_counted_ptr(_Ptr __p) noexcept
: _M_ptr(__p) { }
_Sp_counted_base() noexcept
: _M_use_count(1), _M_weak_count(1) { }
move ctor
__shared_ptr(__shared_ptr&& __r) noexcept
: _M_ptr(__r._M_ptr), _M_refcount()
{
_M_refcount._M_swap(__r._M_refcount);
__r._M_ptr = 0;
}
copy ctor
__shared_ptr(const __shared_ptr&) noexcept = default;
__shared_count(const __shared_count& __r) noexcept
: _M_pi(__r._M_pi)
{
if (_M_pi != 0)
_M_pi->_M_add_ref_copy();
}
__shared_ptr& operator=(const __shared_ptr&) noexcept = default;
__shared_count& operator=(const __shared_count& __r) noexcept
{
_Sp_counted_base<_Lp>* __tmp = __r._M_pi;
if (__tmp != _M_pi)
{
if (__tmp != 0)
__tmp->_M_add_ref_copy();
if (_M_pi != 0)
_M_pi->_M_release();
_M_pi = __tmp;
}
return *this;
}
dtor
~__shared_ptr() = default;
~__shared_count() noexcept
{
if (_M_pi != nullptr)
_M_pi->_M_release();
}
__exchange_and_add_dispatch
Adds the second argument's value to the first argument.
Returns the old value.
void _M_release() noexcept
{
// Be race-detector-friendly. For more info see bits/c++config.
_GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&_M_use_count);
if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, -1) == 1)
{
_GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&_M_use_count);
_M_dispose();
if (_Mutex_base<_Lp>::_S_need_barriers)
{
__atomic_thread_fence (__ATOMIC_ACQ_REL);
}
_GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&_M_weak_count);
if (__gnu_cxx::__exchange_and_add_dispatch(&_M_weak_count,
-1) == 1)
{
_GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&_M_weak_count);
//删除计数器
_M_destroy();
}
}
}
virtual void _M_dispose() noexcept
{
delete _M_ptr;
}
virtual void _M_dispose() noexcept
{
_M_impl._M_del()(_M_impl._M_ptr);
}
reset swap get
use_count unique
类似 size empty
上下行转换
template<typename _Tp, typename _Up>
inline shared_ptr<_Tp>
static_pointer_cast(const shared_ptr<_Up>& __r) noexcept
{
using _Sp = shared_ptr<_Tp>;
return _Sp(__r, static_cast<typename
_Sp::element_type*>(__r.get()));
}
template<typename _Tp, typename _Up>
inline shared_ptr<_Tp>
const_pointer_cast(const shared_ptr<_Up>& __r) noexcept
{
using _Sp = shared_ptr<_Tp>;
return _Sp(__r, const_cast<typename
_Sp::element_type*>(__r.get()));
}
template<typename _Tp, typename _Up>
inline shared_ptr<_Tp>
dynamic_pointer_cast(const shared_ptr<_Up>& __r) noexcept
{
using _Sp = shared_ptr<_Tp>;
if (auto* __p = dynamic_cast<typename
_Sp::element_type*>(__r.get()))
return _Sp(__r, __p);
return _Sp();
}
#if __cplusplus > 201402L
template<typename _Tp, typename _Up>
inline shared_ptr<_Tp>
reinterpret_pointer_cast(const shared_ptr<_Up>& __r) noexcept
{
using _Sp = shared_ptr<_Tp>;
return _Sp(__r, reinterpret_cast<typename
_Sp::element_type*>(__r.get()));
}
#endif
循环引用
#include <iostream>
#include <memory>
#include <vector>
using namespace std;
class ClassB;
class ClassA
{
public:
ClassA() { cout << "ClassA Constructor..." << endl; }
~ClassA() { cout << "ClassA Destructor..." << endl; }
shared_ptr<ClassB> pb; // 在 A 中引用 B
//weak_ptr<ClassB> pb;
};
class ClassB
{
public:
ClassB() { cout << "ClassB Constructor..." << endl; }
~ClassB() { cout << "ClassB Destructor..." << endl; }
shared_ptr<ClassA> pa; // 在 B 中引用 A
//weak_ptr<ClassB> pb;
};
int main()
{
shared_ptr<ClassA> spa = make_shared<ClassA>();
shared_ptr<ClassB> spb = make_shared<ClassB>();
spa->pb = spb;
spb->pa = spa;
std::cout << "spa use_cout:" << spa.use_count() << " spb use_cout:"
<< spb.use_count() << std::endl; //spa: 2 spb:2
}
weak_ptr
ctor
//default ctor
constexpr weak_ptr() noexcept = default;
//copy ctor
weak_ptr(const weak_ptr&) noexcept = default;
template<typename _Yp>
_Assignable<_Yp> operator=(const __weak_ptr<_Yp, _Lp>& __r) noexcept
{
_M_ptr = __r.lock().get();
_M_refcount = __r._M_refcount;
return *this;
}
__weak_count& operator=(const __weak_count& __r) noexcept
{
_Sp_counted_base<_Lp>* __tmp = __r._M_pi;
if (__tmp != nullptr)
__tmp->_M_weak_add_ref();
if (_M_pi != nullptr)
_M_pi->_M_weak_release();
_M_pi = __tmp;
return *this;
}
//move ctor
template<typename _Yp, typename = _Constructible<weak_ptr<_Yp>>>
weak_ptr(weak_ptr<_Yp>&& __r) noexcept
: __weak_ptr<_Tp>(std::move(__r)) { }
//shared_ptr ctor
template<typename _Yp,
typename = _Constructible<const shared_ptr<_Yp>&>>
weak_ptr(const shared_ptr<_Yp>& __r) noexcept
: __weak_ptr<_Tp>(__r) { }
template<typename _Yp, typename = _Compatible<_Yp>>
__weak_ptr(const __shared_ptr<_Yp, _Lp>& __r) noexcept
: _M_ptr(__r._M_ptr), _M_refcount(__r._M_refcount)
{ }
__weak_count(const __shared_count<_Lp>& __r) noexcept
: _M_pi(__r._M_pi)
{
if (_M_pi != nullptr)
_M_pi->_M_weak_add_ref();
}
dtor
~__weak_ptr() = default;
~__weak_count() noexcept
{
if (_M_pi != nullptr)
_M_pi->_M_weak_release();
}
void _M_weak_release() noexcept
{
// Be race-detector-friendly. For more info see bits/c++config.
_GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&_M_weak_count);
if (__gnu_cxx::__exchange_and_add_dispatch(&_M_weak_count, -1) == 1)
{
_GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&_M_weak_count);
if (_Mutex_base<_Lp>::_S_need_barriers)
{
// See _M_release(),
// destroy() must observe results of dispose()
__atomic_thread_fence (__ATOMIC_ACQ_REL);
}
_M_destroy();
}
}
reset swap use_count
expired
Equivalent to use_count() == 0. The destructor for the managed object may not yet have been
called, but this object's destruction is imminent (or may have already happened).
Return value
true if the managed object has already been deleted, false otherwise.
lock 获取指针使用权
std::shared_ptr<T> lock() const noexcept; (since C++11)
Creates a new std::shared_ptr that shares ownership of the managed object. If there is no
managed object, i.e. *this is empty, then the returned shared_ptr also is empty.
Effectively returns expired() ? shared_ptr<T>() : shared_ptr<T>(*this), executed
atomically.
void observe(std::weak_ptr<int> weak)
{
if (auto observe = weak.lock()) {
std::cout << "\tobserve() able to lock weak_ptr<>, value=" <<
*observe << "\n";
} else {
std::cout << "\tobserve() unable to lock weak_ptr<>\n";
}
}
int main()
{
std::weak_ptr<int> weak;
std::cout << "weak_ptr<> not yet initialized\n";
observe(weak);
{
auto shared = std::make_shared<int>(42);
weak = shared;
std::cout << "weak_ptr<> initialized with shared_ptr.\n";
observe(weak);
}
std::cout << "shared_ptr<> has been destructed due to scope exit.\
n";
observe(weak);
}
this 指针 && enable_shared_from_this
class Test
{
public:
std::shared_ptr<Test> GetMe()
{
return std::shared_ptr<Test>(this);
}
};
int main()
{
auto p1 = std::make_shared<Test>();
auto p2 = p1->GetMe();
Test* raw = new Test();
std::shared_ptr<Test> p3(raw);
std::shared_ptr<Test> p4(raw);
return 0;
}
class Test : public std::enable_shared_from_this<Test>
{
public:
std::shared_ptr<Test> GetMe()
{
return shared_from_this();
}
};
code
mutable weak_ptr<_Tp> _M_weak_this;
shared_ptr<_Tp> shared_from_this()
{
return shared_ptr<_Tp>(this->_M_weak_this);
}
template<typename _Tp1>
void _M_weak_assign(_Tp1* __p, const __shared_count<>& __n) const
noexcept
{
_M_weak_this._M_assign(__p, __n);
}
template<typename _Yp, typename _Yp2 = typename remove_cv<_Yp>::type>
typename enable_if<__has_esft_base<_Yp2>::value>::type
_M_enable_shared_from_this_with(_Yp* __p) noexcept
{
if (auto __base = __enable_shared_from_this_base(_M_refcount, __p))
__base->_M_weak_assign(const_cast<_Yp2*>(__p), _M_refcount);
}
template<typename _Yp, typename _Yp2 = typename remove_cv<_Yp>::type>
typename enable_if<!__has_esft_base<_Yp2>::value>::type
_M_enable_shared_from_this_with(_Yp*) noexcept
{ }
戳我跳转
效率
code1
for(int i = 0; i < count; ++i)
{
uint64_t* p = new uint64_t;
*p = 0;
delete p;
}
for(int i = 0; i < count; ++i)
{
auto p = std::make_unique<uint64_t>();
*p = 0;
}
for(int i = 0; i < count; ++i)
{
auto p = std::make_shared<uint64_t>();
*p = 0;
}
new_delete_debug
4500
4000
3500
3000
2500
2000
1500
1000
500
0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
10 50 90 130 170 210 250 290 330 370 410 450 490 530 570 610 650 690 730 770 810 850 890 930 970
raw unique shared
new_delete_release
500
450
400
350
300
250
200
150
100
50
0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
10 50 90 130 170 210 250 290 330 370 410 450 490 530 570 610 650 690 730 770 810 850 890 930 970
raw unique shared
uint64_t* p = new uint64_t;
int k = 0;
for(int i = 0; i < count; ++i)
{
uint64_t* q(nullptr);
q = p;
*q = 0;
++k;
}
auto p1 = std::make_shared<uint64_t>();
for(int i = 0; i < count; ++i)
{
auto q = p1;
*q = 0;
}
auto p2 = std::make_shared<uint64_t>();
for(int i = 0; i < count; ++i)
{
auto& q = p2;
*q = 0;
}
assign_debug
300
250
200
150
100
50
0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
10 50 90 130 170 210 250 290 330 370 410 450 490 530 570 610 650 690 730 770 810 850 890 930 970
raw shared shared&
assign_release
25
20
15
10
0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
10 50 90 130 170 210 250 290 330 370 410 450 490 530 570 610 650 690 730 770 810 850 890 930 970
raw shared shared&
使用场景
https://www.youtube.com/watch?v=JfmTagWcqoE&t=763s
unique_ptr
shared_ptr
weak_ptr
graph
deferred_ptr
https://github.com/hsutter/gcpp
总结
virtual dtor && dll
