C++11：智能指针

常见的内存问题：

• 重复释放同一块内存会导致程序运行崩溃
• 没有及时释放不再使用的内存资源，造成内存泄漏，程序占用的内存资源越来越多
• 有些内存资源已经被释放，但指向它的指针并没有改变指向（成为了野指a

为什么要用智能指针方便和安全的使用动态内存智能指针的行为类似于常规指针 

智能指针的作用：智能指针可以在适当时机自动释放分配的内存，可以很好地避免“忘记释放内存而导致内存泄漏”问题。

头文件：#include 

• shared_ptr  允许多个指针指向同一个对象
• unique_ptr  独占这个对象
• weak_ptr  是一种弱引用指向shared_ptr所管理的对象 

 shared_ptr类：

shared_ptr类似vector，也是一个模板，创建的方式：

	int a = 10;
    //指向int 的shared_ptr
	shared_ptr<int>p(&a);//指向a
    //指向 int的vector 的shared_ptr
	shared_ptr<vector<int>>p1;//默认初始化为nullptr

shared_ptr类的常用成员函数：

shared_ptr的创建的方式：

	shared_ptr<int>b1；
	shared_ptr<int>p;//默认初始化
	shared_ptr<int>p1(b1);//传参
	shared_ptr<int>p2(new int(42));//指向一个值为42的int
	shared_ptr<int>p3 = make_shared<int>(10);//使用make_shared初始化

make_shared的使用：

shared_ptr的最安全的分配和使用动态内存的方法，make_shared会返回指向此对象的shared_ptr

    shared_ptr<int>k1 = make_shared<int>(40);
	shared_ptr<string>k2 = make_shared<string>(5, '3');//字符串可以这样使用 33333
	shared_ptr<int>k3 = make_shared<int>();//默认为0

 常用auto与make_shared一起使用

    auto g1 = make_shared<int>(50);
	auto b(g1);//shared_ptr的拷贝

 当一个shared_ptr的计数器变为0时，它会自动释放自己管理的对象

    auto g1 = make_shared<int>(50);
	auto b(g1);//shared_ptr的赋值
	auto kk = make_shared<int>(100);//kk指向的int只有一个引用者
	kk = b;//给kk赋值，指向另一个内存，r原来指向对象的对象计数器-1==0，当计数器等于0时，自动释放内存

shared_ptr自动销毁所管理的对象：

当指向一个对象的最后一个shared_ptr被销毁时，shared_ptr会调用析构函数来完成销毁。shared_ptr的析构函数会递减它所指向对象的引用计数，引用计数为0，析构函数就会销毁对象，并释放内存。注意：shared_ptr还会自动释放相关联的内存

不要把普通指针和智能指针混合使用：

智能指针的使用：

void text(shared_ptr<int>p)//值传递，会传递一个拷贝，拷贝时会增加引用计数
{
 
}
int main()
{
	shared_ptr<int>p1(new int(20));//p指向一个数据，引用计数为1
	text(p1);//拷贝时，引用计数+1，变为2
	//执行完后引用计数-1，变为1
	int i = *p1;//引用计数为1，没被销毁，正确
	return 0;
}

以下为错误示范：

void text(shared_ptr<int>p)//值传递，会传递一个拷贝，拷贝时会增加引用计数
{
 
}
int main()
{
	int* a(new int(20));//一个普通指针
	text(shared_ptr<int>(a));//合法但内存会被释放
	int j = *a;//a的内存被释放，a为空悬指针
	cout << *a << endl;//该值为未定义
	return 0;
}

不要用get函数去初始化另一个智能指针或为智能指针赋值

	shared_ptr<int> p(new int(20));//引用计数为1
	int* q = p.get();
	{
		shared_ptr<int>(q);//指向相同的内存
	}
	//程序块结束后，q被销毁，指向的内存被释放
	int foo = *p;//未定义，p指向的内存被销毁

 智能指针注意事项：

• 不使用相同的内置指针初始化或（reset）多个智能指针
• 不使用get()初始化或reset另一个指针指针
• 不delete get()返回的指针
• 使用了get()初始化的指针，当最后一个shared_ptr销毁时，指针变为无效
• 使用的智能指针管理的资源不是new分配的内存，需要传递一个删除器

unique_ptr 

一个unique_ptr只拥有它所指向的一个对象

由于只能拥有一个对象，那么unique_ptr，不能使用普通的拷贝和赋值操作

在c++11种没有make_unique,来构造一个unique_ptr，但在c++14种新加了 make_unique

unique_ptr的创建：

	unique_ptr<int>p(new int(20));
    unique_ptr<int>p2();//空指针
    unique_ptr<int>p3(nullptr);//空指针

无法赋值和拷贝：

	unique_ptr<int>p(new int(20));
	unique_ptr<int>p1(p);//报错
	unique_ptr<int>p2;
	p2 = p;//报错

unique_ptr不能拷贝和赋值，但可以把控制权转移：

	unique_ptr<int>p(new int(20));
	unique_ptr<int>p2(p.release());//将控制权转移给p2，把p置空
 
    unique_ptr<int>p5(new int(30));
	unique_ptr<int>p4(move(p5));//使用移动构造函数，p4获得p5的控制权，把p5置为空指针

传递unique_ptr参数和返回unique_ptr

不能拷贝unique_ptr，但可以拷贝或赋值一个将要销毁的unique_ptr

编译器对这种要返回的对象将要销毁，编译器会执行移动构造函数。

unique_ptr<int> text(int p)
{
	return unique_ptr<int>(new int(p));//返回一个unique_ptr
}
unique_ptr<int> text2(int p)
{
	unique_ptr<int>k(new int(p));
	return k;//返回一个局部变量的拷贝
}

weak_ptr

weak_ptr是一种不控制所指向对象生存期的智能指针，指向由shared_ptr管理的对象。 weak_ptr 类型指针的指向和某一 shared_ptr 指针相同时，weak_ptr 指针并不会使所指堆内存的引用计数加 1；同样，当 weak_ptr 指针被释放时，之前所指堆内存的引用计数也不会因此而减 1，weak_ptr是一种“弱”共享对象。

weak_ptr 模板类中没有重载 * 和 -> 运算符，这也就意味着，weak_ptr 类型指针只能访问所指的堆内存，而无法修改它 

weak_ptr指针的创建

	weak_ptr<int>gg();//空的weak_ptr
	shared_ptr<int>p(new int(5));
	weak_ptr<int>k(p);//指向sharead_ptr对象，弱共享，引用计数不会改变

weak_ptr成员函数的使用

	shared_ptr<int>p(new int(5));
	weak_ptr<int>k(p);//指向sharead_ptr对象，弱共享，引用计数不会改变
	shared_ptr<int>k1(k.lock());//k1和k共享对象
	int i = k.use_count();//获取与k共享的shared_ptr的数量
	k.reset();//将k置空