注册 登录  
 加关注
   显示下一条  |  关闭
温馨提示!由于新浪微博认证机制调整,您的新浪微博帐号绑定已过期,请重新绑定!立即重新绑定新浪微博》  |  关闭

还东国的博客

行之苟有恒,久久自芬芳

 
 
 

日志

 
 

(转载)智能指针的实现及原理 + Good ! 句柄类  

2015-10-14 10:19:04|  分类: C++(VC)编程 |  标签: |举报 |字号 订阅

  下载LOFTER 我的照片书  |

智能指针的实现及原理 + Good ! 句柄类

http://blog.csdn.net/aclay/article/details/8299015

2012-12-15 15:05 418人阅读 评论(0) 收藏 举报

C++程序设计的一种常用技术——智能指针(smart pointer),主要内容包括引用计数(reference count)和句柄类(handle class) 当类中有指针成员时,一般有两种方式来管理指针成员:一是采用值型的方式管理,每个类对象都保留一份指针指向的对象的拷贝;另一种更优雅的方式是使用智能指针,从而实现指针指向的对象的共享。

   智能指针(smart pointer)的一种通用实现技术是使用引用计数(reference count)。智能指针类将一个计数器与类指向的对象相关联,引用计数跟踪该类有多少个对象共享同一指针。

 

   每次创建类的新对象时,初始化指针并将引用计数置为1;当对象作为另一对象的副本而创建时,拷贝构造函数拷贝指针并增加与之相应的引用计数;对一个对象进行赋值时,赋值操作符减少左操作数所指对象的引用计数(如果引用计数为减至0,则删除对象),并增加右操作数所指对象的引用计数;调用析构函数时,构造函数减少引用计数(如果引用计数减至0,则删除基础对象)。

 

   实现引用计数有两种经典策略:一是引入辅助类,二是使用句柄类。下面分别介绍这些内容。

问题描述

   假设有一个名为TestPtr的类,里面有一个指针成员,简化为如下代码:

class TestPtr

{

public:

    TestPtr(int *p): ptr(p) { }

    ~TestPtr( ) { delete ptr; }

    // other operations

private:

    int *ptr;

    // other data

};

 

在这种情况下,类TestPtr对象的任何拷贝、赋值操作都会使多个TestPtr对象共享相同的指针。但在一个对象发生析构时,指针指向的对象将被释放,从而可能引起悬垂指针。

   现在我们使用引用计数来解决这个问题,一个新的问题是引用计数放在哪里。显然,不能放在TestPtr类中,因为多个对象共享指针时无法同步更新引用计数。

方案一

   这里给出的解决方案是,定义一个单独的具体类(U_Ptr)来封装指针和相应的引用计数。由于这个类只是用于对类HasPtr中的成员指针ptr进行了封装,无其它用途,所以把引用计数类U_Ptr的所有成员均定义为private,并把类HasPtr声明为它的友元类,使HasPtr类可以访问U_Ptr类。例代码如下:

[cpp] view plaincopy

#include <iostream> 

using namespace std; 

class U_Ptr {  // 计数类, 我们不希望普通用户使用,所以都为 private 

    private : 

        friend class HasPtr; 

    private : 

        U_Ptr(int *p) : ip(p), use(1) {} 

        ~U_Ptr() {delete ip;} 

 

        int *ip; 

        size_t use; 

}; 

class HasPtr { 

    public : 

        HasPtr(int *p, int i) : ptr(new U_Ptr(p)), val(i) {} 

        HasPtr(const HasPtr &orig) : ptr(orig.ptr), val(orig.val) {++ptr->use;} 

        HasPtr& operator=(const HasPtr&); 

        ~HasPtr() { 

            if((--ptr->use) == 0) delete ptr; 

        } 

    private : 

        U_Ptr *ptr; 

        int val; 

}; 

HasPtr& HasPtr::operator=(const HasPtr &rhs) { 

    ++rhs.ptr->use; 

    if(--ptr->use == 0) { 

        delete ptr; 

    } 

    ptr = rhs.ptr; 

    val = rhs.val; 

    return *this; 

int main() { 

    return 0; 

   当希望每个HasPtr对象中的指针所指向的内容改变而不影响其它对象的指针所指向的内容时,可以在发生修改时,创建新的对象,并修改相应的引用计数。这种技术的一个实例就是写时拷贝(Copy-On-Write)。

这种方案的缺点是每个含有指针的类的实现代码中都要自己控制引用计数,比较繁琐。特别是当有多个这类指针时,维护引用计数比较困难。

方案二

   为了避免上面方案中每个使用指针的类自己去控制引用计数,可以用一个类把指针封装起来。封装好后,这个类对象可以出现在用户类使用指针的任何地方,表现为一个指针的行为。我们可以像指针一样使用它,而不用担心普通成员指针所带来的问题,我们把这样的类叫句柄类。在封装句柄类时,需要申请一个动态分配的引用计数空间,指针与引用计数分开存储。实现示例如下:

[cpp] view plaincopy

#include <iostream> 

#include <stdexcept> 

#define BUG cout << "here\n"; 

using namespace std; 

 

#define TEST_SMARTPTR 

class Stub { 

public: 

    void print() { 

        cout<<"Stub: print"<<endl; 

    } 

    ~Stub(){ 

        cout<<"Stub: Destructor"<<endl; 

    } 

}; 

 

template <typename T> 

class SmartPtr { 

public: 

    SmartPtr(T *p = 0): ptr(p), pUse(new size_t(1)) { } 

    SmartPtr(const SmartPtr& src): ptr(src.ptr), pUse(src.pUse) { 

        ++*pUse; 

    } 

    SmartPtr& operator= (const SmartPtr& rhs) { 

        // self-assigning is also right 

        ++*rhs.pUse; 

        decrUse(); 

        ptr = rhs.ptr; 

        pUse = rhs.pUse; 

        return *this; 

    } 

    T *operator->() { 

        if (ptr) 

            return ptr; 

        throw std::runtime_error("access through NULL pointer"); 

    } 

    const T *operator->() const { 

        if (ptr) 

            return ptr; 

        throw std::runtime_error("access through NULL pointer"); 

    } 

    T &operator*() { 

        if (ptr) 

            return *ptr; 

        throw std::runtime_error("dereference of NULL pointer"); 

    } 

    const T &operator*() const { 

        if (ptr) 

            return *ptr; 

        throw std::runtime_error("dereference of NULL pointer"); 

    } 

    ~SmartPtr() { 

        decrUse(); 

#ifdef TEST_SMARTPTR 

        std::cout<<"SmartPtr: Destructor"<<std::endl; // for testing 

#endif 

    } 

 

private: 

    void decrUse() { 

        --(*pUse); // 虚析构 

        if (*pUse == 0) { // 

            delete ptr; 

            delete pUse; 

        } 

    } 

    T *ptr; 

    size_t *pUse; 

}; 

 

int main() { 

    try { 

        SmartPtr<Stub> t; 

        t->print(); 

    } catch (const exception& err) { 

        cout << err.what() << endl; 

    } 

    BUG 

    SmartPtr<Stub> t1(new Stub); 

    SmartPtr<Stub> t2(t1); 

    SmartPtr<Stub> t3(new Stub); 

    BUG 

    t3 = t2; 

    BUG 

    t1->print(); 

    BUG 

    (*t3).print(); 

 

    return 0; 

}  

  评论这张
 
阅读(238)| 评论(0)
推荐 转载

历史上的今天

在LOFTER的更多文章

评论

<#--最新日志,群博日志--> <#--推荐日志--> <#--引用记录--> <#--博主推荐--> <#--随机阅读--> <#--首页推荐--> <#--历史上的今天--> <#--被推荐日志--> <#--上一篇,下一篇--> <#-- 热度 --> <#-- 网易新闻广告 --> <#--右边模块结构--> <#--评论模块结构--> <#--引用模块结构--> <#--博主发起的投票-->
 
 
 
 
 
 
 
 
 
 
 
 
 
 

页脚

网易公司版权所有 ©1997-2017