C++中的智能指针是用一个类对另一个对象的指针或者引用进行管理，具体对该类的管理可以用包含对象指针以及引用计数的类来记录；
一般有两种方式实现：
1. 在对象内部记录引用的个数，这需要对象预留引用计数相关的接口
2. 用一个单独的资源管理类进行管理，则不需要修改对象
下面主要是第二种方法：（参考）http://blog.csdn.net/hackbuteer1/article/details/7561235
智能指针类将一个计数器与类指向的对象相关联，引用计数跟踪该类有多少个对象共享同一指针。每次创建类的新对象时，初始化指针并将引用计数置为1；当对象作为另一对象的副本而创建时，拷贝构造函数拷贝指针并增加与之相应的引用计数；对一个对象进行赋值时，赋值操作符减少左操作数所指对象的引用计数（如果引用计数为减至0，则删除对象），并增加右操作数所指对象的引用计数；调用析构函数时，构造函数减少引用计数（如果引用计数减至0，则删除基础对象）。
#include<iostream>
using namespace std;
// 定义仅由HasPtr类使用的U_Ptr类，用于封装使用计数和相关指针
// 这个类的所有成员都是private，我们不希望普通用户使用U_Ptr类，所以它没有任何public成员
// 将HasPtr类设置为友元，使其成员可以访问U_Ptr的成员
class U_Ptr
{
friend class HasPtr;
int *ip;
size_t use;
U_Ptr(int *p) : ip(p) , use(1)
{
cout << "U_ptr constructor called !" << endl;
}
~U_Ptr()
{
delete ip;
cout << "U_ptr distructor called !" << endl;
}
};
class HasPtr
{
public:
// 构造函数：p是指向已经动态创建的int对象指针
HasPtr(int *p, int i) : ptr(new U_Ptr(p)) , val(i)
{
cout << "HasPtr constructor called ! " << "use = " << ptr->use << endl;
}
// 复制构造函数：复制成员并将使用计数加1
HasPtr(const HasPtr& orig) : ptr(orig.ptr) , val(orig.val)
{
++ptr->use;
cout << "HasPtr copy constructor called ! " << "use = " << ptr->use << endl;
}
// 赋值操作符
HasPtr& operator=(const HasPtr&);
// 析构函数：如果计数为0，则删除U_Ptr对象
~HasPtr()
{
cout << "HasPtr distructor called ! " << "use = " << ptr->use << endl;
if (--ptr->use == 0)
delete ptr;
}
// 获取数据成员
int *get_ptr() const
{
return ptr->ip;
}
int get_int() const
{
return val;
}
// 修改数据成员
void set_ptr(int *p) const
{
ptr->ip = p;
}
void set_int(int i)
{
val = i;
}
// 返回或修改基础int对象
int get_ptr_val() const
{
return *ptr->ip;
}
void set_ptr_val(int i)
{
*ptr->ip = i;
}
private:
U_Ptr *ptr; //指向使用计数类U_Ptr
int val;
};
HasPtr& HasPtr::operator = (const HasPtr &rhs) //注意，这里赋值操作符在减少做操作数的使用计数之前使rhs的使用技术加1，从而防止自我赋值
{
// 增加右操作数中的使用计数
++rhs.ptr->use;
// 将左操作数对象的使用计数减1，若该对象的使用计数减至0，则删除该对象
if (--ptr->use == 0)
delete ptr;
ptr = rhs.ptr; // 复制U_Ptr指针
val = rhs.val; // 复制int成员
return *this;
}
int main(void)
{
int *pi = new int(42);
HasPtr *hpa = new HasPtr(pi, 100); // 构造函数
HasPtr *hpb = new HasPtr(*hpa); // 拷贝构造函数
HasPtr *hpc = new HasPtr(*hpb); // 拷贝构造函数
HasPtr hpd = *hpa; // 拷贝构造函数
cout << hpa->get_ptr_val() << " " << hpb->get_ptr_val() << endl;
hpc->set_ptr_val(10000);
cout << hpa->get_ptr_val() << " " << hpb->get_ptr_val() << endl;
hpd.set_ptr_val(10);
cout << hpa->get_ptr_val() << " " << hpb->get_ptr_val() << endl;
delete hpa;
delete hpb;
delete hpc;
cout << hpd.get_ptr_val() << endl;
int *p2 = new int(56);
HasPtr *ka = new HasPtr(p2,57);
cout<<ka->get_ptr_val()<<" "<<ka->get_ptr_val()<<endl;
return 0;
}
更简单的实现：仅对一个对象进行管理
存在的问题： 没有理解智能指针的本质，用static 变量来保存所生成该对象引用的个数，会导致对无法对别的对象进行管理。（如果新生成一个资源对象，则static变量并不会归1，另外资源管理类赋值或者拷贝构造函数是对对象的拷贝或者赋值，而不是引用。 今天犯了一个大错误，this是当前对象的指针，要引用其成员变量，需要用->,最近编写java多了，C中指针基本操作给忘了）
#include <iostream>
using namespace std;
class Book {
public:
Book(int no):no(no){
}
void test(){
cout<<no<<endl;
}
~Book(){
cout<<"~Book"<<endl;
}
private:
int no;
};
class SmartPtr {
public:
static int cnt;
SmartPtr(){
}
SmartPtr(Book *t){
this->t = t;
cnt++;
}
SmartPtr( SmartPtr &rhs){
rhs.cnt++;
this->t = rhs.t;
}
SmartPtr(SmartPtr * rhs){
rhs->cnt++;
t = rhs->t;
}
SmartPtr operator=(const SmartPtr &rhs){
if(this==&rhs) {
return *this;
}
rhs.cnt++;
this->t = rhs.t;
return *this;
}
Book operator*(){
return *t;
}
Book * operator->(){
return t;
}
~SmartPtr() {
cout<<"enter the descrutor:"<< cnt<<endl;
if(--cnt == 0) {
delete t;
}
cout<<cnt<<endl;
}
private:
Book * t;
};
int SmartPtr::cnt = 0;
int main(){
Book *b1 = new Book(3);
SmartPtr *sp1 = new SmartPtr(b1);
SmartPtr *sp2 = new SmartPtr(sp1);
SmartPtr *sp3 = new SmartPtr(sp1);
(*sp3)->test();
delete sp3;
delete sp2;
delete sp1;
return 0;
}