智能指针

当类中有指针成员时，一般有两种方式来管理指针成员:一是采用值型的方式管理，每个类对象都保留一份指针指向的对象的拷贝;另一种更优雅的方式是使用智能指针，从而实现指针指向的对象的共享。那么智能指针是什么呢？智能指针是存储指向动态分配(堆)对象指针的类。

很多人都以为智能指针是一个指针，但其实它是一个模板，它可以自动释放所指向的对象。我们来看一下：

1.    Auto_ptr

auto_ptr在STL中早就存在了，auto_ptr是通过权限转移的方式来防止值拷贝所带来

的问题，所谓权限转移就是说开辟的动态内存任何时刻只能由一个指针指向。

#include<iostream>

using namespacestd;

template <classT>

class Auto_ptr {

private:

       T *ptr;

public:

       Auto_ptr(T *p)

              :ptr(p)

       {}

       ~Auto_ptr()

       {

              delete ptr;

       }

};

void main()

{

       Auto_ptr<int> p(new int(1));

       Auto_ptr<int> p1(new int(1));

       p1 = p;

}

在主函数中，我们使p1=p，可以发现它出现了bug，这是因为Auto_ptr是支持复制的，但是两个Auto_ptr都包括了一个指针，当它们析构的时候，同一个指针就会被析构两次，当然会出现问题。我们应该怎样解决呢？再来看：

#include<iostream>

using namespacestd;

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(Auto_ptr &p)

    {

       ptr = p.ptr;

       owner = p.owner;

       p.owner = false;

    }

    Auto_ptr &operator=(Auto_ptr &p)

    {

       if (this != &p)

       {

           if (owner)

           {

              delete ptr;

           }

           ptr = p.ptr;

           owner = p.owner;

           p.owner = false;

       }

       delete p;

       return this;

    }

};

voidmain()

{

    Auto_ptr<int> p(new int(1));

    Auto_ptr<int> p1(p);

}

为了防止拷贝，又引入了scoped_ptr,就是把拷贝构造函数在private中定义，或者只在public中声明，但不写它的定义，意思就是使其不能拷贝。

为了更方便，我们又引入了shared_ptr,它的思想就是“引用计数”，每次有一个shared_ptr关联到某个对象上时，计数值就加上1；相反，每次有一个shared_ptr析构时，相应的计数值就减去1。当计数值减为0的时候，就执行对象的析构函数，此时该对象才真正被析构！

 

#include<iostream>

using namespace std;

template <class T>

class Shared_ptr {

private:

       T*ptr;

       int*count;

public:

       Shared_ptr(T*p)

              :ptr(p),count(new int(1))

       {}

       Shared_ptr(Shared_ptr&p)

              :ptr(p.ptr)

              ,count(p.count)

       {

              ++(*count);

       }

       ~Shared_ptr()

       {

              if(!(--(*count)))

              {

                     deleteptr;

                     deletecount;

                     ptr= NULL;

                     count= NULL;

                     cout<< "~Shared_ptr()" << endl;

              }

       }

       Shared_ptr&operator=(Shared_ptr &p)

       {

              if(ptr != p.ptr)//不能用this!=&p判断，因为有可能是多个指向相同的空间的指针进行的赋值

              {

                     if((*count) == 1)

                     {

                            deleteptr;

                            deletecount;

                     }

                     ptr= p.ptr;

                     count= p.count;

                     ++(*count);

              }

              returnthis;

       }

};

struct BB {

       intdata;

       Shared_ptr<BB>next;

       Shared_ptr<BB>pre;

       BB()

              :data(0)

              ,next(NULL)

              ,pre(NULL)

       {}

};

void main()

{

       Shared_ptr<BB>p(newBB());

       Shared_ptr<BB>p1(new BB());

}

这个结果就是：

~Shared_ptr()

~Shared_ptr()

~Shared_ptr()

~Shared_ptr()

~Shared_ptr()

~Shared_ptr()

为什么会析构六次呢，我们来画个图看一下

如果把主函数的两行代码改成

p->next = p1;

p1->pre = p;

就会得到：

~Shared_ptr()

~Shared_ptr()

这是为什么呢？

因为Shared_ptr(强引用)不能循环引用，所以又引入了Weak_ptr（弱引用）

template <class T>

class Weak_ptr {

private:

       T*ptr;

public:

       Weak_ptr(T*p)

              :ptr(p)

       {}

       ~Weak_ptr()

       {

              deleteptr;

       }

       Weak_ptr&opreator = (Shared_ptr<T> &p)

       {

              ptr= p.ptr;

              return*this;

       }

}

*在使用的时候必须将Weal_ptr声明为Shared_ptr的友元类。

看一下仿函数：

#include<iostream>

using namespace std;

struct com {

       booloperator()(int a, int b)

       {

              return(a > b);

       }

};

int main()

{

       comc;

       cout<< c(1, 2) << endl;

}

我们可以使用仿函数来定制删除器：

#include<iostream>

using namespace std;

//普通删除器

struct Del {

       voidoperator()(void *p)

       {

              deletep;

       }

};

//文件删除器

struct Del2 {

       voidoperator()(FILE *p)

       {

              fclose(p);

       }

};

再来看一下拷贝

就这么多咯。(*^▽^*)