C++句柄

我们知道C++中最令人头疼的当属指针，如果您申请了对象却没有释放它，时间一长就会造成系统崩溃，大量的内存溢出使得您的程序的健壮性出现问题


而句柄类就是为了能够解决这一问题而出现的，句柄类有点类似于智能指针。


好了，废话不多说，我们来看代码


首先我们来看 sample.h文件的代码：


/* 
* author:xizero00 
* mail:[e-mail] 
* date:2011-08-07 20:11:24  
* Handle Class Sample  句柄类示例 
*/  
  
#ifndef SAMPLE_H   
#define SAMPLE_H   
  
#include <iostream>   
#include <stdexcept>   
using namespace std;  
  
  
  
  
//基类   
class Item_base  
{  
public:  
    //基类的虚函数,用于智能地复制对象   
    virtual Item_base* clone() const  
    {  
        return new Item_base( *this );  
    }  
};  
  
  
//子类   
class Bulk_item: public Item_base  
{  
    //子类的虚函数的重载,用于智能地复制对象   
    virtual Bulk_item* clone() const  
    {  
        return new Bulk_item( *this );  
    }  
};  
  
//子类的子类   
class Sales_item: public Bulk_item  
{  
public:  
    //默认构造函数,用来初始化一个引用计数器   
    Sales_item(): p( 0 ) , use( new size_t( 1 ) ) { cout << "Sales_item的引用计数器初始化为1" << endl; }  
      
    //带有一个参数的,且该参数为基类引用的构造函数   
    Sales_item( const Item_base& );  
      
      
      
    //复制构造函数,需要注意的是，每复制一次就需要增加引用计数一次   
    Sales_item( const Sales_item &i ): p( i.p ) , use( i.use ) { ++*use; cout << "由于采用了复制构造函数,Sales_item类型的对象引用计数为:" << *use << endl;} //也可以这样写   
    //Sales_item( const Sales_item &i ): p( i.clone() ) , use( new size_t( 1 ) ) { ++*use; }   
      
      
    //析构函数,析构的时候会判断是否能够释放指针所指向的数据   
    ~Sales_item() { cout << "在析构函数中:"; decr_use(); }  
      
      
    //赋值操作符重载   
    Sales_item& operator= ( const Sales_item& );  
      
    //访问操作符重载   
    const Item_base* operator-> () const  
    {  
        if( p )  
        {  
            return p;  
        }  
        else  
        {  
            throw logic_error( "p指针错误" );  
        }  
    }  
      
    //解引用操作符重载   
    const Item_base& operator* () const  
    {  
        if( p )  
        {  
            return *p;  
        }  
        else  
        {//重载虚函数,用于智能地复制对象   
            throw logic_error( "p指针错误" );  
        }  
    }  
      
      
    //重载虚函数,用于智能地复制对象   
    /* 
    virtual Sales_item* clone() const 
    { 
        return new Sales_item( *this ); 
    } 
    */  
      
private:  
    //两个指针存储着引用计数器以及数据的指针   
    Item_base *p;  
    size_t *use;  
      
    //减少引用   
    void decr_use()  
    {  
        cout << "在 dec_use函数中引用计数减少了,当前计数值为:" << *use - 1 << endl;  
        if( --*use == 0 )  
        {  
            delete p;  
            delete use;  
            cout << "在 dec_use函数中计数器减为0,释放对象" << endl;  
        }  
          
    }  
};  
  
  
//赋值操作符重载,每次复制都会增加引用计数   
Sales_item& Sales_item::operator= ( const Sales_item &si )  
{  
    cout << "由于采用类赋值操作,";  
    cout << "被赋值的对象的引用计数为:" << *si.use ;  
    cout << "即将被赋值的对象的引用计数为:" << *use << endl;  
    //这里需要特别注意的就是待复制的对象的计数器需要加1而被赋值的对象需要减1     
      
    //增加被复制对象的引用计数   
    ++*si.use;  
    cout << "被赋值的对象的赋值之后的引用计数为:" << *si.use << endl;  
    //将即将被赋值的对象的引用计数减1   
    decr_use();  
    cout << " 即将被赋值的对象赋值之后的引用计数为:" << *use << endl;  
      
      
    //复制指针   
    p = si.p;  
    use = si.use;  
      
    //返回   
    return *this;  
}  
  
  
#endif //SAMPLE_H 
接下来我们来看sample.cc的代码：


/* 
* author:xizero00 
* mail:[e-mail] 
* date:2011-08-07 20:11:24  
*/  
#include "sample.h"   
int main( int argc , char **argv )  
{  
    //重点关注i1和i2的引用计数   
    Sales_item i1 , i2;//i1和i2的引用计数分别为1   
    Sales_item i3( i1 );//i1的引用计数变为2   
    Sales_item i4 = i1;//i1的引用计数变为3,因为这样还是调用的复制构造函数   
    i4 = i2; // i2的引用计数变为2   
      
    return 0;  
}  
下面给出编译所需的Makefile


# author:xizero00  
# mail:[e-mail]  
# date:2011-08-08 00:51:25   
install:  
    g++ sample.cc -g -o sample  
    ls -al sample*  
    ./sample  
clean:  
    rm -f sample  
    ls -al sample*  
注意：代码是在linux下编译，您只需要将三个文件放在同一个目录，然后在当前目录打开终端，输入make，就可以查看到结果。


如果您想清理生成的文件 输入make clean即可


下面是我执行的结果：


Sales_item的引用计数器初始化为1  
Sales_item的引用计数器初始化为1  
由于采用了复制构造函数,Sales_item类型的对象引用计数为:2  
由于采用了复制构造函数,Sales_item类型的对象引用计数为:3  
由于采用类赋值操作,被赋值的对象的引用计数为:1即将被赋值的对象的引用计数为:3  
被赋值的对象的赋值之后的引用计数为:2  
在 dec_use函数中引用计数减少了,当前计数值为:2  
 即将被赋值的对象赋值之后的引用计数为:2  
在析构函数中:在 dec_use函数中引用计数减少了,当前计数值为:1  
在析构函数中:在 dec_use函数中引用计数减少了,当前计数值为:1  
在析构函数中:在 dec_use函数中引用计数减少了,当前计数值为:0  
在 dec_use函数中计数器减为0,释放对象  
在析构函数中:在 dec_use函数中引用计数减少了,当前计数值为:0  
在 dec_use函数中计数器减为0,释放对象  
结论：我们可以看到，句柄类能够很方便并且能够很安全地释放内存，不会导致内存的泄露。