C++11特性-智能指针

        智能指针是存储指向动态分配（堆）对象指针的类，确保离开指针所在的作用域时，自动销毁动态分配的对象，防止内存泄漏。智能指针实现的核心技术是引用计数，每使用一次，内部引用计数加1，每析构一次内部引用计数减1，减为0时，删除所指向的堆内存。

        智能指针使用需要包含头文件

1.共享智能指针shared_ptr

         shared_ptr是个模板类，可以通过构造函数、reset、shared_ptr辅助函数初始化

        use_count查看引用计数、get方法获取原始指针

//构造函数初始化
	//shared_ptr<T> 智能指针名字 （创建堆内存）;//构造函数初始化
// 拷贝、移动构造函数初始化
 
// make_shared初始化
	//template <class T,class....Args>
	// shared_ptr <T> make_shared(Args .... args)
//reset构造函数初始化
	//void reset() noexcept;
 
	//template <class Y> 
	//void reset(Y *ptr);
 
	//template <class Y,class Deleter>
	//void reset(Y* ptr, Deleter d);
 
	//template <class Y, class Deleter,class Alloc>
	//void reset(Y* ptr, Deleter d,Alloc alloc);
//prt指向要获取所有权的对象指针，d指向要获取所有权的对象指针,alloc内部存储器所用的分配器
//获取原始指针
	//T *get() const noexcept;

    //构造函数初始化
	shared_ptr <int> ptr1(new int(3));
	// 移动构造函数初始化
	shared_ptr <int> ptr2 = move(ptr1);
	// 拷贝构造函数初始化
	shared_ptr <int> ptr3 = ptr2;
	// make_shared初始化
	shared_ptr <int> ptr4 = make_shared<int>(4);
	shared_ptr <EPtr> ptr5 = make_shared<EPtr>(4);
	shared_ptr <EPtr> ptr6 = make_shared<EPtr>("hello,world");
	//reset构造函数初始化
	ptr6.reset();
	ptr5.reset(new EPtr(99));
	
	//获取原始指针使用
	EPtr* t = ptr5.get();
	t->set(1000);
	t->pritf();
 
	//智能指针使用
	ptr5->set(999);
	ptr5->pritf();
	cout << endl;

        智能指针删除器

                当智能指针引用计数为0时，会自动释放内存。也可以指定在初始化智能指针时指定删除器函数（本质为回调函数），一般为lambda表达式。管理数组的智能指针必须指定删除器函数（也可以使用C++的srd::default_delete()函数）

    //shared_ptr <EPtr> ppp2(new EPtr[3]);//只释放一次
	//cout << endl;
 
	shared_ptr <EPtr> ppp3(new EPtr[3], [](EPtr* ptr) {
		cout << "数组必须指定删除器函数 -----------------" << endl;
		delete[] ptr;
		});
	cout << endl;
 
	shared_ptr <EPtr> ppp5(new EPtr[3],default_delete<EPtr[]>());
	std::cout << endl;
 
	shared_ptr <int> ppp4(new int[3], default_delete<int[]>());
	cout << endl;

       注意事项：

                不能使用一个地址初始化多个共享智能指针（通过智能指针给智能指针赋值解决）

                函数不能管理返回this的共享智能指针对象（通过weak_ptr解决）

                共享智能指针不能循环引用（通过weak_ptr解决）

2.独占智能指针unique_ptr

        内部引用计数为1，如另一个智能指针需要使用这块对内存，是需要使用move函数来转移

        不允许将一个unique_ptr赋值给另一个unique_ptr

    //构造函数初始化
	unique_ptr <int> ptr1(new int(3));
 
	// 移动构造函数初始化
	unique_ptr <int> ptr2 = move(ptr1);
	
	//reset构造函数初始化
	ptr2.reset();
	ptr2.reset(new int(99));
 
	//获取原始指针使用
	unique_ptr <EPtr> ptr3(new EPtr(4));
	EPtr* t = ptr3.get();
	t->set(100);
	t->pritf();

        指定删除器不一样，需要在<>里面加入删除器函数类型

    using funPtr = void(*)(EPtr *);
	unique_ptr <EPtr, funPtr> ptr3(new EPtr("HELLO"), [](EPtr* t) {
		cout << "test_unique_ptrDelete---------" << endl;
		delete t; });
 
	//c11中unique_ptr能自动申请与释放数组地址
	unique_ptr <EPtr[]> ptr4(new EPtr[3]);
	//c11中shared_ptr不支持下面方法，才c11后才支持
	shared_ptr <EPtr[]> ptr5(new EPtr[3]);

3.弱引用之智能指针weak_ptr

        不共享指针，不操作资源，来监视shared_ptr(协调shared_ptr)，主要解决返回this的shared_ptr与循环引用问题

    use_count:获取shared_ptr内的引用计数
	expired:判断资源是否被释放，true-释放，false-没有释放
	lock:获取shared_ptr的资源对象
	reset:释放，让其不监视shared_ptr的资源

class MyClassPtr :public enable_shared_from_this<MyClassPtr>
{
public:
	shared_ptr<MyClassPtr> getPtr() {
		//return shared_ptr<MyClassPtr>(this);
		return shared_from_this();
	}
 
	~MyClassPtr() {
		cout << "析构"<<endl;
	}
};
 
    MyClassPtr* objPtr = new MyClassPtr;
	shared_ptr<MyClassPtr> ptr1 (objPtr);
	//不能使用一个地址初始化多个共享智能指针,会释放多次
	//shared_ptr<MyClassPtr> ptr2(objPtr);//error
	shared_ptr<MyClassPtr> ptr2 = ptr1;
 
	shared_ptr<MyClassPtr> sptr1(new MyClassPtr);
	cout << "引用计数 = "<<sptr1.use_count() << endl;
	//函数不能管理返回this的共享智能指针对象
	//使用弱引用的模板类(enable_shared_from_this)来管理返回this的共享智能指针对象
	//enable_shared_from_this<T>通过shared_from_this()方法来返回共享智能指针
	//shared_from_this函数内部通过weak_ptr的lock()返回shared_ptr对象
	shared_ptr<MyClassPtr> sptr2 = sptr1->getPtr();
	cout << "引用计数 = " << sptr2.use_count() << endl;