c++智能指针

• 智能指针的基本概念
• • 1、smart pointer
• 一、auto_ptr
• 二、unique_ptr
• • 1、unique_ptr初始化
  • 2、unique_ptr成员函数
• 三、share_ptr
• • 1、shared_ptr基本概念
  • 2、shared_ptr初始化
  • 3、shared_ptr原理
  • 4、shared_ptr成员函数
• 四、weak_ptr
• • 1、weak_ptr基本概念
  • 2、weak_ptr初始化
  • 3、成员函数
  • 4、获取管理当前对象this的shared_ptr
  • 5、解决shared_ptr循环引用问题
• 五、删除器
• 总结

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

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

#include 

using namespace std;
template 
class SmartPtr{
public:
	SmartPtr(T* _ptr):ptr(_ptr){}  //构造函数
	
	~SmartPtr(){
		if (ptr != nullptr) {  //析构函数
			cout<<"smartprt: delete"<
	SmartPtr prt_int(new int(1));  //指向int类型的智能指针
	SmartPtr prt_string(new string("abc"));   //指向string类型的智能指针
	return 0;
}

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

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

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

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

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

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

	//解除对原始内存的管理
	ptr_re.reset();
	//重新指定智能指针管理的原始内存
	ptr_re.reset(new int(2));
	//get()方法可以获取智能智能指针管理的原始地址
	cout<<"ptr addr = " << ptr_re.get()<#include 
#include 
using namespace std;
int main(int argc, char *argv[]) {
	shared_ptr ptr(new int(1));
	shared_ptr ptr_cp = ptr;

	cout< 
2、shared_ptr初始化 
1. 通过拷贝和移动构造函数初始化
 通过拷贝方式初始化共享智能指针对象，两个对象会同时管理一块内存，对应的引用计数会增加；如果使用移动放入方式初始化共享智能指针对象，只是转移了内存的所有权，管理内存的对象不会增加，对应的引用计数也不会增加。
 2. 通过make_shared辅助函数初始化
 make_shared可以完成内存对象的创建并将地址传递给共享智能指针。如果要创建一个类对象，函数（）内需填写构造指定对象所需要的参数。
 3. 通过reset函数初始化
 如果智能指针有值，调用reset()会使智能指针的引用计数减1。
 
class Test {
public:
	Test(){
		cout<<"construct Test"<
		cout<<"construct Test, x= "<< x <
		cout<<"constuuct Test, x= " << x <
		cout<<"destruct Test"<
	//构造函数
	shared_ptr ptr(new int(1));
	shared_ptr ptr_cp = ptr;
	//移动构造函数
	shared_ptr ptr_move = move(ptr);
	shared_ptr ptr_move2(move(ptr_move));

	cout<<"count="< ptr1 = make_shared(1);
	shared_ptr ptr2 = make_shared();
	shared_ptr ptr3 = make_shared(1);
	shared_ptr ptr4 = make_shared("hello");

	//通过reset方法初始化
	shared_ptr 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初始化 
默认构造函数
拷贝构造函数
通过shared_ptr对象初始化
 
#include 
#include 
#include 
using namespace std;
int main(int argc, char *argv[]) {
	shared_ptr sp(new int(1));

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

	//通过shared_ptr构造一个可用的weak_ptr实例
	weak_ptr wp3(sp);
	//通过shared_ptr构造一个可用的weak_ptr实例（隐式类型转换）
	weak_ptr wp4 = sp;
	cout<<"wp1 use_count = " <#include 
#include 
#include 
using namespace std;
class Test :public enable_shared_from_this
{
public:
	//在shared_from_this()函数内部使用weak_ptr监测this对象，并通过调用weak_ptr的lock() 方法返回shared_ptr对象
	//从而避免了一个对象被析构两次
	shared_ptr getSharedPtr() 
	{
		return shared_from_this();
	}
	~Test()
	{
		cout<<"destruct Test"<
	shared_ptr sp_test(new Test());
	shared_ptr sp_test2 = sp_test->getSharedPtr();

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

	~TA()
	{
		cout<<"destruct TA"<
	shared_ptr pta;

	~TB()
	{
		cout<<"destruct TB"<
	shared_ptr ta(new TA());
	shared_ptr tb(new TB());

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


	return 0;
}
 
 
五、删除器 
智能指针初始化的时候可以指定删除动作，这个删除操作对应的函数是删除器。删除器本质是一个回调函数，我们只需进行实现，其调用是由智能指针完成。
 在c++11中，当智能指针指向数组时，需要指定删除器，因为默认删除器不支持数组对象。
 自定义删除器可以是函数指针、仿函数、lembda、包装器。
 
#include 
#include 
#include 
using namespace std;
template
class DelAll 
{
public:
	void operator()(const T* p)
	{
		cout<<"delete[] - operator."<
void deletPtr(T* p) 
{
	cout<<"delete[] - fun."<
	//仿函数
	shared_ptr pt(new int[10], DelAll());

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

	return 0;
}


 
 
总结