实现一个简单的智能指针

// helloworld.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include<iostream>
using namespace std;

//指针类
class I_Pointer{
private:
int ref_count;
int *p;
I_Pointer(int *p): p(p), ref_count(1){}; //构造函数
~I_Pointer(){
cout<<"Delete shared pointer"<<endl;
}
friend
class Has_Ptr;
};

//有指针成员的类
class Has_Ptr{
private:
I_Pointer *ptr; //指针成员
//减少引用计数
void release_ref_count(){
cout<<"release reference count"<<endl;
if(--(ptr->ref_count) == 1){
free_and_nil();
}
}
//增加引用计数
void add_ref(){
cout<<"add reference count"<<endl;
++(ptr->ref_count);
}
//指针释放
void free_and_nil(){
delete ptr;
ptr = NULL;
}

public:
// 带int指针的构造函数
Has_Ptr(int *ptr): ptr(new I_Pointer(ptr)) {
add_ref();
}

Has_Ptr(){} //默认构造

Has_Ptr(const Has_Ptr &rhs){ //拷贝构造
memcpy(this, &rhs, sizeof(rhs));
add_ref();
}

~Has_Ptr(){
release_ref_count();
}

//赋值
Has_Ptr &operator=(const Has_Ptr &rhs){
//原来的引用计数减1
release_ref_count();
memcpy(this, &rhs, sizeof(&rhs));
//新的引用计数加1
add_ref();
return *this;
}

void set_ptr(int *ptr){
if (ptr != (this->ptr->p)){
this->ptr->p = ptr;
}
}
int* get_ptr(){
return ptr->p;
}
};

void test(){
int i = 0;
Has_Ptr hp(&i);
int j = 1;
Has_Ptr hp1(&j);
hp1 = hp;
}
int _tmain(int argc, _TCHAR* argv[])
{
test();
return 0;
}

　　当一个类的成员里面有指针的时候，使用默认拷贝构造函数的时候就会造成多个对象管理同一块内存

这样带来的后果就是，如果任意一个对象释放了这一块内存，那么其他的对象再来操作这块内存的时候就会发生预料不到的结果。

为了避免对象中保存野指针从而引发的错误，提出了智能指针， 它能实现多个对象共享内存的自释放。

　　其实这种实现有点类似于delphi中的接口，到处传来传去的，最后自释放，就是因为接口有引用计数，当引用计数为1的时候就把对象释放掉。

　　C++中这种实现（C++ Primer书上借鉴来的），有几个比较巧妙的地方

Has_Ptr这个类其实是想保存一个int *的指针，为了避免悬垂指针的出现，我们使用了 I_Pointer这个类把悬垂指针包了一下，因此在Has_Ptr这个类的Public接口中不会出现I_Pointer，只会出现int *

事实上也不能出现I_Pointer， 因为Pointer的构造函数定义成Private，不允许在外面构造，只能在friend类中构造，I_Pointer是专门为Has_Ptr实现的

要记住三元组（拷贝构造，赋值操作，析构），当其中一个需要有特殊操作的时候，其他的也需要有特殊操作，这个要形成定势思维。