C++智能指针详解

1.智能指针的产生背景及发展历史：

在C++中动态内存的管理由一对运算符来管理：new，为动态内存分配空间并返回一个指向该对象的指针；delete，接受一个动态对象的指针，并销毁该对象，释放与之相关联的内存。有时我们忘记释放内存，造成内存泄漏；有时在有指针引用内存的情况下就释放了它，在这种情况下会产生引用非法内存的指针。

RAII（Resource Acquisition Is Initialization）,也称为为“资源获取就是初始化”，是C++语言的一种管理资源、避免泄漏的惯用法。C++标准保证任何情况下，已构造的对象最终会销毁，即它的析构函数最终会被调用。简单的说，RAII 的做法是使用一个对象，在其构造时获取资源，在对象生命期控制对资源的访问使之始终保持有效，最后在对象析构的时候释放资源。通过应用RAII思想，就产生了智能指针：
智能纸指针的行为类似常规指针;重要的是它负责自动释放所指的对象。

2.模拟实现智能指针

template <class T>
class AutoPtr
{
public:
AutoPtr(T *ptr)
:_ptr(ptr)
{
}
~AutoPtr()
{
if (_ptr != NULL)
{
delete _ptr;
_ptr = NULL;
}
}
AutoPtr(AutoPtr <T> & ap)
:_ptr(ap._ptr)
{
ap._ptr = NULL;
//只能有一个对象的成员指针指向同一块区域,前一个对象的成员指针置为空指针
}

T& operator  //注意返回值问题不能返回一个临时变量,临时变量具有常性,会导致不能通过解引用更改值
{
return *(this->_ptr);
}

AutoPtr& operator=(AutoPtr &ap)
{
//防止自赋值
if (this != &ap)
{
delete _ptr;
this->_ptr = ap._ptr;
ap._ptr = NULL;
}
return *this;
}

T*  operator->()
{
//this->_ptr->;
return _ptr;
}
private:
T *_ptr;
};

class AA
{
public:
int _a;
int _b;
};

//测试用例

void TestAutoPtr()
{
AutoPtr<int> ap1(new int);
*ap1 = 10;
AutoPtr<int> ap2(ap1);
//*ap1 = 20;
//这句代码会导致程序崩溃，因为当有两个对象的成员指针指向同一块区域
//时，前一个对象的成员指针会被置成空指针
AutoPtr<int> ap3(new int(20));
ap2 = ap3;
AutoPtr<AA> ap4(new AA);
ap4->_a = 10;
ap4->_b = 20;
ap2 = ap3;
}

template<class T>
class ScopedPtr
{
public:
ScopedPtr(T *ptr)
:_ptr(ptr)
{
}

~ScopedPtr()
{
if (_ptr)
{
delete _ptr;
_ptr = NULL;
}
}

T& operator *()
{
return  *(_ptr);
}

T* operator ->()
{
return _ptr;
}
protected:
//构造和拷贝构造只声明，不定义
ScopedPtr& operator=(const ScopedPtr & sp);
ScopedPtr(const ScopedPtr & sp);
private:
T* _ptr;
};

class AA
{
public:
int _a;
int _b;
};

//测试用例
void TestScopedPtr()
{

ScopedPtr<int> ap1(new int);
*ap1 = 10;
ScopedPtr<int> ap3(new int(10));
//  ap3 = ap1;
//  ScopedPtr<int> ap4(ap1);
//上述两句代码编译不通过，因为ScopedPtr的构造和拷贝构造只声明，没定义，
//且为了防止别人进行修改定义为保护或者私有成员
ScopedPtr<AA> ap2(new AA);
ap2->_a = 10;
ap2->_b = 20;
}

仿函数(functor)，就是使一个类的使用看上去象一个函数。其实现就是类中实现一个operator()，这个类就有了类似函数的行为，就是一个仿函数类了。
没有使用仿函数，就不能实现SharedPtr的多种功能，只使用delete删除的话，如果是new[]的空间，就会造成内存泄漏。

template<class T>
struct DeleteArray
{
void operator()(T *ptr)
{
delete[] ptr;
}

};

template&l
4000
t;class T>
struct Delete
{
void operator()(T *ptr)
{
delete ptr;
}

};

struct Fclose
{
void operator()(FILE * ptr)
{
fclose(ptr);
}
};

template<class T,class Del>
class SharedPtr
{
public:
SharedPtr(T *ptr)
:_ptr(ptr)
, _reference_count(new int (1))
{
}
~SharedPtr()
{
Clear();
}
void Clear()
{
if (--(*_reference_count) == 0)
{
_del(_ptr);
delete _reference_count;
_reference_count = NULL;
}

}
SharedPtr( SharedPtr<T,Del> & sp)
{
_ptr = sp._ptr;
_reference_count = sp._reference_count;
(*_reference_count)++;
}

//传统写法
//SharedPtr& operator =(const SharedPtr<T,Del> & sp)
//{
//  if (this != &sp)
//  {
//      Clear();
//      _ptr = sp._ptr;
//      _reference_count = sp._reference_count;
//      (*_reference_count)++;
//  }
//  return *this;
//}

//现代写法
SharedPtr& operator =(SharedPtr<T,Del> sp)
{
swap(_ptr, sp._ptr);
swap(_reference_count, sp._reference_count);
return *this;
}
T& operator *()
{
return *(this->_ptr);
}

T*  operator->()
{
return _ptr;
}
private:
T *_ptr;
Del _del;
int *_reference_count;
};

//测试用例
void TestSharedPtr()
{
SharedPtr<int,Delete<int>> ap3(new int(10));
SharedPtr<int,Delete<int>> ap4(ap3);
SharedPtr<int,DeleteArray<int>> ap5(new int[10]);
SharedPtr<FILE, Fclose>ap6(fopen("text.txt", "w"));
}

shared_ptr虽然功能强大，但是存在一些问题，比如说循环引用问题。

struct ListNode
{
shared_ptr<ListNode> _prev;
//shared_ptr为库文件中实现的，只需包memory即可使用
shared_ptr<ListNode> _next;
int data;
ListNode(int x)
{
data = x;
_prev = NULL;
_next = NULL;
}
~ListNode()
{
cout << "~ListNode()" << endl;
}
};
int main()
{
shared_ptr<ListNode> cur(new ListNode(1));
shared_ptr<ListNode> next(new  ListNode(2));
cur->_next = next;
next->_prev = cur;
return 0;
}

weak_ptr是一种不控制所指对象生存周期的智能指针，它指向一个shared_ptr所管理的对象。将一个weak_ptr绑定到shared_ptr不会改变shared_ptr的引用计数。一旦最后一个指向对象的shared_ptr被销毁，对象就会被释放。weak_ptr的名字抓住了这种智能指针“弱”共享对象的特点。

3.智能指针的总结