智能指针

一、Auto_ptr指针

把Auto_ptr指针封装成一个类，指针出了Auto_ptr的作用域会通过析构函数自动释放。

#include "stdafx.h"
#include <iostream>
#include"Auto_ptr.h"
using namespace std;
template<class T>
int*p = new int;
class Auto_ptr {
public:
Auto_ptr(T*p) :_ptr(p), _owner(true)*p = 2;
{}
~Auto_ptr()
{
delete _ptr;
cout << "delete" << endl;
}
T&operator*()
{
return*ptr;
}
T&operator->()
{
return->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;
}
private:
T*_ptr;
bool_owner;
};

管理权的转移 -- 设置一个标志位 每次只能是最后一个对象有管理权 

auto_ptr是支持复制的，一旦允许复制，就很容易发现一个问题——若两个auto_ptr对象都包含了同一个指针（即指向同个对象，同一块内存），那么当它们都析构的时候，同一个对象就会被析构两次！

解决方法是很简单了，auto_ptr的做法是：当发生复制/赋值时，把被复制/赋值的对象内部的指针值赋值为NULL，这样始终只有一个auto_ptr对象指向同一个对象，所以保证了不会多次析构！

二、Scoped_ptr指针

防拷贝 只声明不定义，而且是在 private 里面的 

#include "stdafx.h"
#include <iostream>
#include"Scoped_ptr.h"
using namespace std;
template<class T>
class Scoped_ptr {
public:
Auto_ptr(T*p) :_ptr(p)
{}
private:
Scoped_ptr(Scoped_ptr &p);//拷贝构造函数，只声明不实现
T*_ptr;
};
void Test Scoped_ptr()
{
Scoped_ptr<int>p(int new(5));
p1(p);//拷贝不可访问，报错。
}

三、Shared_ptr指针

引用计数的浅拷贝（注意不是写时拷贝） 
赋值运算符的重载 注意这里，不能使用 this != &pa 进行 判断，因为有可能是多个指向相同的空间的指针进 行的赋值 

#include "stdafx.h"
#include <iostream>
#include"Shared_ptr.h"
using namespace std;
template<class T>
class Shared_ptr {
public:
Shared_ptr(T*p) :_ptr(p),_count(new int(1))
{}
~Shared_ptr()
{
if(!(--(*_count)))//取反
{
delete _ptr;
delete _count;
_ptr = NULL;
_count = NULL;
cout << "delete" << endl;
}
}
Shared_ptr(Shared_ptr &p):_ptr(p._ptr),_count(p._count)
{
++(*_count);
}

T&operator*()
{
return*_ptr;
}
T*operator->()
{
return->ptr;
}
private:
T*_ptr;
int *_count;
};

}Shared_ptr&operator=(Shared_ptr&p)
{
if (_ptr != p._ptr)
{
if((*_count)==1)
{
delete _ptr;                 //把原来指向内容释放掉
delete _count;
cout << "delete operator=" << endl;
}
_ptr = p._ptr;
_count = p._count;
++(*_count);
}
return *this;
}

struct BB

{

int data;

Shared_ptr<BB>_next;

Shared_ptr<BB>_prev;

};

BB()

{

data=0;

_next=NULL;

_prev=NULL;

}

void TestShe()

{

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

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

p->_next=p1;

p1->-prev=p;

}

无限循环，不能释放。

所以定义了Weak_ptr

四、Weak_ptr指针

template<class T>

class Shared_ptr

{

friend class Weak_ptr;

}

class Weak_ptr

{

public:

Weak_ptr(T*p)

{}

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

{_ptr=p._ptr;}

weak_ptr无引用计数，只能指向Shared_ptr的引用空间

五、仿函数

仿函数：创建一个对象，使它像函数一样使用

struct  Com

{

bool operator()(int a,int b)

{return a>b;}

}

六、删除器

用删除器删除文件指针