融会贯通C++智能指针教程

 template class SmartPtr { public: SmartPtr(T* ptr = nullptr):_ptr(ptr) {} ~SmartPtr() {delete _ptr;} private: T* _ptr; }; int main(){ SmartPtr ptr(new int); return 0; } 

 const T& operator*() const{return *_ptr;} T& operator*(){return *_ptr;} const T operator->() const{return _ptr;} T operator->(){return _ptr;} 

 int main(){ SmartPtr ptr1(new int); SmartPtr ptr2(ptr1); return 0; } 

 auto_ptr(auto_ptr& _Right) noexcept : _Myptr(_Right.release()) {} _Ty* release() noexcept { _Ty* _Tmp = _Myptr; _Myptr    = nullptr; return _Tmp; } 

 auto_ptr ptr1(new int); auto_ptr ptr2(ptr1); 

 template , int> = 0> unique_ptr(unique_ptr&& _Right) noexcept : _Mypair(_One_then_variadic_args_t{}, _STD forward<_dx>(_Right.get_deleter()), _Right.release()) {} unique_ptr(unique_ptr<_Ty2, _Dx2>&& _Right) noexcept : _Mypair(_One_then_variadic_args_t{}, _STD forward<_dx2>(_Right.get_deleter()), _Right.release()) {} // 拷贝构造或者赋值运算符的时候，用于将以前的智能指针置空 pointer release() noexcept { return _STD exchange(_Mypair._Myval2, nullptr); } unique_ptr(const unique_ptr&) = delete; unique_ptr& operator=(const unique_ptr&) = delete; 

 unique_ptr ptr1(new int); unique_ptr ptr2(std::move(ptr1));// 使用右值引用的拷贝构造，由于执行了release，ptr1已经被置空 cout << (ptr1 == nullptr) << endl;    // true ptr2 = std::move(ptr1);               // 使用右值引用的operator=赋值重载函数 cout << (ptr2 == nullptr) << endl;    // true 

 unique_ptr get_unique_ptr() { unique_ptr tmp(new int); return tmp; } int main(){ unique_ptr ptr = get_unique_ptr(); // 调用带右值引用参数的拷贝构造函数，由tmp直接构造ptr return 0; } 

 #include  #include  using namespace std; template class RefCnt { public: RefCnt(T* ptr = nullptr){ mcount = (mptr == nullptr) ? 0 : 1; } void addRef() { mcount++; } int subRef() { return --mcount; } private: int mcount;      // mptr指向某个资源的引用计数，线程不安全。使用atomic_int线程安全 T* mptr;         //指向智能指针内部指向资源的指针，间接指向资源 }; template class SmartPtr { public: SmartPtr(T* ptr = nullptr) :_ptr(ptr) { cout << "SmartPtr()" << endl; mpRefCnt = new RefCnt(_ptr); // 用指向资源的指针初始化引用计数对象 } ~SmartPtr() { if (0 == mpRefCnt->subRef()) { cout << "释放资源析构~SmartPtr()" << endl; delete _ptr; } else { cout << "空析构~SmartPtr()" << endl; } } const T& operator*() const { return *_ptr; } T& operator*() { return *_ptr; } const T operator->() const { return _ptr; } T operator->() { return _ptr; } SmartPtr(const SmartPtr& src) :_ptr(src._ptr), mpRefCnt(src.mpRefCnt) { cout << "SmartPtr(const SmartPtr& src)" << endl; if (_ptr != nullptr) { // 用于拷贝的对象已经引用了资源 mpRefCnt->addRef(); } } SmartPtr& operator=(const SmartPtr& src) { cout << "SmartPtr& operator=" << endl; if (this == &src) { return *this; } // 当前智能指针指向和src相同的资源，考虑是否释放之前的资源 if (0 == mpRefCnt->subRef()) { // 若之前指向的资源引用计数为1，释放之前的资源 delete _ptr; } _ptr = src._ptr; mpRefCnt = src.mpRefCnt; mpRefCnt->addRef(); return *this; } private: T* _ptr;        // 指向资源的指针 RefCnt* mpRefCnt; // 指向该资源引用计数的指针 }; int main(){ SmartPtr ptr1(new int); SmartPtr ptr2(ptr1); SmartPtr ptr3; ptr3 = ptr2; *ptr2 = 100; cout << *ptr2 << " " << *ptr3 << endl; return 0; } 

 #include  #include  using namespace std; class B; class A { public: A() { cout << "A()" << endl; } ~A() { cout << "~A()" << endl; } shared_ptr _ptrb; }; class B { public: B() { cout << "B()" << endl; } ~B() { cout << "~B()" << endl; } shared_ptr _ptra; }; int main() { shared_ptr pa(new A()); shared_ptr pb(new B()); pa->_ptrb = pb; pb->_ptra = pa; cout << pa.use_count() << endl; cout << pb.use_count() << endl; return 0; } /* A() B() 2 2 */ 

 class B; class A { public: A() { cout << "A()" << endl; } ~A() { cout << "~A()" << endl; } weak_ptr _ptrb; }; class B { public: B() { cout << "B()" << endl; } ~B() { cout << "~B()" << endl; } weak_ptr _ptra; }; /* A() B() 1 1 ~B() ~A() */ 

 #include  #include  #include  using namespace std; class A { public: A() { cout << "A()" << endl; } ~A() { cout << "~A()" << endl; } void test() { cout << "test()" << endl; } }; void handler01(A* q) { // 睡眠2s，使得主线程进行delete std::this_thread::sleep_for(std::chrono::seconds(2)); q->test(); } int main() { A* p = new A(); thread t1(handler01, p); delete p; t1.join(); return 0; } 

 #include  #include  #include  using namespace std; class A { public: A() { cout << "A()" << endl; } ~A() { cout << "~A()" << endl; } void test() { cout << "test()" << endl; } }; void handler01(weak_ptr pw) { shared_ptr ps = pw.lock(); // lock方法判定资源对象是否析构 if (ps != nullptr) { ps->test(); }else { cout << "A对象已经析构，无法访问" << endl; } } int main() { { shared_ptr p(new A()); //开启一个新线程，并传入共享对象的弱智能指针 thread t1(handler01, weak_ptr(p)); // 将子线程和主线程的关联分离，也就是说detach()后子线程在后台独立继续运行， // 主线程无法再取得子线程的控制权，即使主线程结束，子线程未执行也不会结束。 t1.detach(); } // 让主线程等待，给时间子线程执行，否则main函数最后会调用exit方法结束进程 std::this_thread::sleep_for(std::chrono::seconds(2)); return 0; } 

 template class ArrDeletor { public: // 对象删除的时候需要调用对应删除器的()重载函数 void operator()(T* ptr) const { cout << "ArrDeletor::operator()" << endl; delete[] ptr; } }; template class FileDeletor { public: // 对象删除的时候需要调用对应删除器的()重载函数 void operator()(T* fp) const { cout << "FileDeletor::operator()" << endl; fclose(fp); } }; int main() { unique_ptr> ptr1(new int[100]); unique_ptr> ptr2(fopen("1.cpp", "w")); // 使用lambda表达式 // function<返回值(参数)> // []叫做捕获说明符，表示一个lambda表达式的开始。接下来是参数列表，即这个匿名的lambda函数的参数 unique_ptr> ptr1( new int[100], [](int* p)->void { cout << "call lambda release new int[]" << endl; delete[] p; } ); unique_ptr>  ptr2( fopen("1.cpp", "w"), [](FILE* p)->void { cout << "call lambda release fopen(\"1.cpp\", \"w\")" << endl; fclose(p); } ); return 0; }