c++11智能指针

---

智能指针的基本概念

1、smart pointer

c++没有垃圾回收机制，必须自己分配释放的内存，否则就会照成内存泄漏。解决这个问题的有效方法，就是智能指针（smart pointer）。智能指针是指向动态分配（堆）对象的指针的类，可用于生存期的控制，能保证在离开智能指针所在的作用域时，自动销毁动态分配的对象，防止内存泄漏。智能指针实现的核心技术是引用技术，每使用一次，内部引用计数加1，每析构一次，内部引用计数减1，当引用计数减为0，删除所指向的堆内存。

智能指针的本质是类模版，当智能指针所指向的对象使用完后，对象会自动调用析构函数去释放指针所指向的空间。
以下是智能指针基本框架，所有智能指针类模版都包含一个对象指针、构造函数、析构函数

#include <iostream>

using namespace std;
template <typename T>
class SmartPtr{
public:
	SmartPtr(T* _ptr):ptr(_ptr){}  //构造函数
	
	~SmartPtr(){
		if (ptr != nullptr) {  //析构函数
			cout<<"smartprt: delete"<<endl;
			delete ptr;
			ptr = nullptr;
		}
	}
private:
	T* ptr;   //指针对象
};
int main(int argc, char *argv[]) {
	SmartPtr<int> prt_int(new int(1));  //指向int类型的智能指针
	SmartPtr<string> prt_string(new string("abc"));   //指向string类型的智能指针
	return 0;
}

---

一、auto_ptr

上述自定义智能指针没有定义拷贝构造函数和赋值重载函数，如果调用原生的拷贝构造函数和赋值重载函数，就会造成程序崩溃。

	SmartPtr<int> ptr_int(new int(1));
	SmartPtr<int> ptr_int_cp(ptr_int);

auto_ptr解决该问题的措施是管理权转移的思想，即原对象拷贝给新对象，原对象就会被设置成nullptr。此时就只有新对象指向资源空间。如果此时再去调用原对象，那整个程序会崩溃，所以现在很多公司禁用auto_ptr。

---

二、unique_ptr

unique_ptr是c++11提供的智能指针，它直接禁用拷贝构造函数和赋值构造函数。

1、unique_ptr初始化

1. unique_ptr可以通过构造函数初始化；
2. unique_ptr可以通过std::move转移给其他unique_ptr；
3. unique_ptr可以通过函数返回转移给其他unique_ptr；

#include <iostream>
#include <memory>
using namespace std;
unique_ptr<int> func() {
	return unique_ptr<int>(new int(1));
}
int main(int argc, char *argv[]) {
	//通过构造函数初始化
	unique_ptr<int> ptr(new int(1));
	//通过转移所有权的方式初始化
	unique_ptr<int> ptr_cp = move(ptr);
	//通过函数返回的方式初始化
	unique_ptr<int> ptr_re = func();

	//解除对原始内存的管理
	ptr_re.reset();
	//重新指定智能指针管理的原始内存
	ptr_re.reset(new int(2));
	//get()方法可以获取智能智能指针管理的原始地址
	cout<<"ptr addr = " << ptr_re.get()<<endl;
	cout<<"ptr content = " <<*ptr_re.get()<<endl;
	return 0;
}

2、unique_ptr成员函数

• reset()：解除对原始内存的管理
• reset(new int(2))：重新指定智能指针管理的原始内存
• get()：获取智能指针管理的原始地址

---

三、share_ptr

1、shared_ptr基本概念

shared_ptr是c++11提供的智能指针，允许多个shared_ptr指向同一块资源，并且保证共享资源只会被释放一次，所以程序不会崩溃。

#include <iostream>
#include <memory>
using namespace std;
int main(int argc, char *argv[]) {
	shared_ptr<int> ptr(new int(1));
	shared_ptr<int> ptr_cp = ptr;

	cout<<ptr.get()<<endl;
	cout<<ptr_cp.get()<<endl;
	return 0;
}

2、shared_ptr初始化

1. 通过拷贝和移动构造函数初始化
通过拷贝方式初始化共享智能指针对象，两个对象会同时管理一块内存，对应的引用计数会增加；如果使用移动放入方式初始化共享智能指针对象，只是转移了内存的所有权，管理内存的对象不会增加，对应的引用计数也不会增加。
2. 通过make_shared辅助函数初始化
make_shared可以完成内存对象的创建并将地址传递给共享智能指针。如果要创建一个类对象，函数（）内需填写构造指定对象所需要的参数。
3. 通过reset函数初始化
如果智能指针有值，调用reset()会使智能指针的引用计数减1。

class Test {
public:
	Test(){
		cout<<"construct Test"<<endl;
	}

	Test(int x){
		cout<<"construct Test, x= "<< x <<endl;
	}

	Test(string x) {
		cout<<"constuuct Test, x= " << x <<endl;
	}

	~Test(){
		cout<<"destruct Test"<<endl;
	}
};
int main(int argc, char *argv[]) {
	//构造函数
	shared_ptr<int> ptr(new int(1));
	shared_ptr<int> ptr_cp = ptr;
	//移动构造函数
	shared_ptr<int> ptr_move = move(ptr);
	shared_ptr<int> ptr_move2(move(ptr_move));

	cout<<"count="<<ptr_move2.use_count()<<endl;

	//make_shared初始化
	shared_ptr<int> ptr1 = make_shared<int>(1);
	shared_ptr<Test> ptr2 = make_shared<Test>();
	shared_ptr<Test> ptr3 = make_shared<Test>(1);
	shared_ptr<Test> ptr4 = make_shared<Test>("hello");

	//通过reset方法初始化
	shared_ptr<int> ptr5;
	ptr5.reset(new int(1));
	return 0;
}

3、shared_ptr原理

shared_ptr采用引用计数的原理实现多个shared_ptr之间的资源共享。

• shared_ptr内部会维护一个引用计数，记录这个资源被多少智能指针对象共享。
• 当一个shared_ptr对象销毁时（调用析构函数），析构函数内会将引用计数减1。
• 当引用计数为0，说明自己是最后一个使用该资源的shared_ptr对象，必须释放资源。
• 当引用计数不为0，说明还有其他对象在使用该资源，则不能释放资源，否则其他对象会成为野指针。

因为计数指针所指向的对象在堆上，所有的线程都可以访问该资源，多线程在修改引用计数的时候会出现现场安全的问题，所以要用锁来保证线程安全。

4、shared_ptr成员函数

• use_count(); 查看当前有多少智能指针同时管理这块内存
• reset()
• reset(创建的堆内存)
• get()

---

四、weak_ptr

1、weak_ptr基本概念

weak_ptr不共享指针，不能操作资源，它的构造不会增加引用计数，析构也不会减少引用计数，它的主要作用是监测shared_ptr所管理的资源是否存在。

2、weak_ptr初始化

1. 默认构造函数
2. 拷贝构造函数
3. 通过shared_ptr对象初始化

#include <iostream>
#include <memory>
#include <string>
using namespace std;
int main(int argc, char *argv[]) {
	shared_ptr<int> sp(new int(1));

	//构造weak_ptr空对象(默认构造函数)
	weak_ptr<int> wp1;
	//空对象（拷贝构造函数）
	weak_ptr<int> wp2(wp1);

	//通过shared_ptr构造一个可用的weak_ptr实例
	weak_ptr<int> wp3(sp);
	//通过shared_ptr构造一个可用的weak_ptr实例（隐式类型转换）
	weak_ptr<int> wp4 = sp;
	cout<<"wp1 use_count = " <<wp1.use_count()<<endl;
	cout<<"wp3 use_count = " <<wp3.use_count()<<endl;
	return 0;
}

3、成员函数

1. use_count()：获取所观测资源的引用计数
2. expired()：判断锁观测的资源是否被释放
3. lock()：获取所观测资源的shared_ptr对象
4. reset()：清空对象，使其不监测任务资源

4、获取管理当前对象this的shared_ptr

c++11提供了模版类std::enable_shared_from_this，通过类中的方法shared_from_this()返回共享智能指针。

#include <iostream>
#include <memory>
#include <string>
using namespace std;
class Test :public enable_shared_from_this<Test>
{
public:
	//在shared_from_this()函数内部使用weak_ptr监测this对象，并通过调用weak_ptr的lock() 方法返回shared_ptr对象
	//从而避免了一个对象被析构两次
	shared_ptr<Test> getSharedPtr() 
	{
		return shared_from_this();
	}
	~Test()
	{
		cout<<"destruct Test"<<endl;
	}
};
int main(int argc, char *argv[]) 
{
	shared_ptr<Test> sp_test(new Test());
	shared_ptr<Test> sp_test2 = sp_test->getSharedPtr();

	return 0;
}

5、解决shared_ptr循环引用问题

智能指针如果循环引用会造成内存泄漏

#include <iostream>
#include <memory>
#include <string>
using namespace std;
struct TA;
struct TB;
struct TA
{
	//shared_ptr<TB> ptb;  如果使用shared_ptr, 智能指针离开作用域时，引用计数都为1，
	//这种情况不会去删除智能指针所指向的内存，导致实例对象不能被析构，最终导致内存泄漏，
	//解决方式是ta或tb的任意一个成员改成weak_ptr。
	weak_ptr<TB> ptb;

	~TA()
	{
		cout<<"destruct TA"<<endl;
	}
};

struct TB
{
	shared_ptr<TA> pta;

	~TB()
	{
		cout<<"destruct TB"<<endl;
	}
};
int main(int argc, char *argv[]) 
{
	shared_ptr<TA> ta(new TA());
	shared_ptr<TB> tb(new TB());

	ta->ptb = tb;
	tb->pta = ta;


	return 0;
}

---

五、删除器

智能指针初始化的时候可以指定删除动作，这个删除操作对应的函数是删除器。删除器本质是一个回调函数，我们只需进行实现，其调用是由智能指针完成。
在c++11中，当智能指针指向数组时，需要指定删除器，因为默认删除器不支持数组对象。
自定义删除器可以是函数指针、仿函数、lembda、包装器。

#include <iostream>
#include <memory>
#include <string>
using namespace std;
template<typename T>
class DelAll 
{
public:
	void operator()(const T* p)
	{
		cout<<"delete[] - operator."<<endl;
		delete[] p;
	}
};

//自定义删除器函数
template<typename T>
void deletPtr(T* p) 
{
	cout<<"delete[] - fun."<<endl;
	delete[] p;
}

int main(int argc, char *argv[]) 
{
	//仿函数
	shared_ptr<int> pt(new int[10], DelAll<int>());

	//lembda
	shared_ptr<int> pt_lem(new int[10], [](int* p){cout<<"delete[] - lembda."<<endl; delete[] p;});
	
	//自定义删除器函数
	shared_ptr<int> pt_fun(new int[10], deletPtr<int>);
	
	//c++提供的删除器函数 std::default_delete<T>()
	shared_ptr<int> pt_default(new int[10], default_delete<int[]>());

	return 0;
}

---

总结