我们都知道指针是指向一片内存空间的，可是当两个指针指向同一空间，假如要销毁一个指针，那这一片空间应该也被销毁，那么此时另一个指针应该怎样？

针对这样的问题，人们想出了“智能指针”。

auto_ptr:

template <class T> class Auto_ptr { private: T *ptr; public: Auto_ptr(T *p) :ptr(p) {} ~Auto_ptr() { delete ptr; } }; int main() { Auto_ptr<int> p(new int(1)); Auto_ptr<int> p1(new int); p = p1; return 0; }
此时析构时，两个对象都是用了一个指针，也就是说，两个对象同用了一片内存空间，这样在析构时，同一片内存将会被释放两次，程序就会出错。
将auto_ptr改进一下，使只有一个指针指向一片空间是才能够释放 
#include<iostream> using namespace std; template <class T> class Auto_ptr { private: T *_ptr; bool _owner; public: Auto_ptr(T *p) :_ptr(p),_owner(true) {} ~Auto_ptr() { if (_owner) { delete _ptr; } } Auto_ptr& operator=(Auto_ptr &p) { if (this != &p) { if (_owner) { delete _ptr; } _ptr = p._ptr; _owner = p._owner; p._owner = false; } return *this; } Auto_ptr(Auto_ptr &p) { _ptr = p._ptr; _owner = p._owner; p._owner = false; } }; int main() { Auto_ptr<int> p(new int(1)); Auto_ptr<int> p1(new int); p = p1; return 0; }
 scoped_ptr:

这个很简单粗暴，它禁止了赋值操作和复制构造。

class scoped_ptr{ public:  scoped_ptr(T *p):_ptr(p)  {} private:  scoped_ptr(scoped_ptr &p); private:  T *_ptr; }
他将拷贝构造函数定义为私有，直接禁止了复制构造。

但是如果程序需要在多个不同的地方用到同一份内容，那么就会很麻烦。因此人们又想出了share_ptr
share_ptr:

class shared_ptr { private: T *_ptr; int *_count; public: shared_ptr(T *p):_ptr(p),_count(new int(1)) {} ~shared_ptr() { if (!(--(*_count))) { delete _ptr; delete _count; _ptr = NULL; _count = NULL;
 cout << "~xigou" << endl; } else { --(*_count); } } shared_ptr(shared_ptr &p) :_ptr(p._ptr),_count(p._count) { ++(*count); } shared_ptr& operator=(shared_ptr &p) { if (_ptr != p._ptr) { if ((*_count) == 1) { delete _ptr; delete _count; } _ptr = p._ptr; _count = p._count; ++(*(_count)); } return *this; } }; int main() { shared_ptr<int> p(new int(1)); shared_ptr<int> p1(new int); p = p1; return 0; }
shared_ptr使用引用计数！每次有一个shared_ptr关联到某个对象上时，计数值就加上1；相反，每次有一个shared_ptr析构时，相应的计数值就减去1。当计数值减为1的时候，就执行对象的析构函数，此时该对象才真正被析构！由此，shared_ptr很明显是支持复制构造和赋值操作的，因为它有了计数机制之后，就不需要scoped_ptr那样严格地控制复制、赋值来维护析构操作的时机。
 
struct BB { int date; shared_ptr<BB> next; shared_ptr<BB> prev; BB() : date(0), next(0), prev(0) {} }; int main() { shared_ptr<BB> p(new BB()); shared_ptr<BB> p1(new BB()); }

运行结果为：


而人们又渐渐的发现了循环引用，如下：

int main() { shared_ptr<BB> p(new BB()); shared_ptr<BB> p1(new BB); p->s = p1; p1->f = p; }
此时只析构两次。为什么呢？
除了p的prev和p1的next，其他都没被释放，

一般来讲，解除这种循环引用有下面方法：

  1. 当只剩下最后一个引用的时候需要手动打破循环引用释放对象
  2. 使用弱引用的智能指针打破这种循环引用。

但方法1需要程序员手动控制，麻烦且容易出错。这里主要介绍一下第三种方法，弱引用的智能指针weak_ptr。

weak_ptr:

template <class T> class weak_ptr { private: T *_ptr; public: weak_ptr(T *p):_ptr(p) {} ~weak_ptr() { cout << " " << endl; delete _ptr; } weak_ptr& operator=(shared_ptr p) { _ptr = p._ptr; }; };
由于弱引用不更改引用计数，类似普通指针，只要把循环引用的一方使用弱引用，即可解除循环引用。

最后值得一提的是,虽然通过弱引用指针可以有效的解除循环引用，但这种方式必须在程序员能预见会出现循环引用的情况下才能使用，也可以是说这个仅仅是一种编译期的解决方案，如果程序在运行过程中出现了循环引用，还是会造成内存泄漏的。因此，不要认为只要使用了智能指针便能杜绝内存泄漏。


仿函数：

#include<iostream> using namespace std; struct cm { bool operator()(int a, int b) { return (a > b); } }; int main() { cm a; a(1, 2); return 0; }

删除器：

#include<iostream> using namespace std; //文件删除器 struct Fclose { void operator()(FILE*& fp) { cout << "Fclose()" << endl; fclose(fp); } }; //普通删除器 struct del { void operator()(void *p) { delete(p); p = NULL; } };