C++中智能指针的实现

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;

}

改进实现： 引用计数类单独对内存进行管理；

UseCount.h

class UseCount

{

friend class Handler;

public:

UseCount(void):p(new int(1)) //一个资源的计数初始化只生成一份，然后拷贝和赋值同时管理

{

}

~UseCount(void)

{

if(--*p == 0 ) {

delete p;

}

}

UseCount(const UseCount& rhs):p(rhs.p){

++*rhs.p;

}

UseCount & operator=(const UseCount & rhs){

++*rhs.p;

if(--*p == 0){

delete p;

}

p = rhs.p;

}

bool only(){

return *p == 1;

}

private:

int *p;

};

Handler.h 负责对资源管理

class Handler

{

public:

~Handler(void){

if(u.only()) {

delete p;

} else {

std::cout<< "jjj" << endl;

}

}

Handler(const Point & point):p(new Point(point)) //资源仅生成一份

{

}

Handler(const Handler &h):p(h.p),u(h.u){

}

Handler & operator=(const Handler &h){

p = h.p;

u = h.u;

return *this;

}

private:

Point *p;

UseCount u;

};

Point.h

#pragma once

class Point

{

public:

Point(void){

}

~Point(void){

}

};

main.cpp

#include <iostream>

#include "Handler.h"

#include "Point.h"

using namespace std;

int main() {

Point p;

Handler h1(p);

Handler* h2 = new Handler(h1);

Handler* h3 = new Handler(h1);

delete h3;

delete h2;

Point p1;

Handler j1(p1);

getchar();

return 0;

}