~Person()
         {
           //...
           delete [] home;
         }
     }

  深拷贝之后，新旧对象的home成员指向的内容的值相同，而其自身的值不同。这样就可避免出现其中之一
  destroy 之后，另一对象的home成员不可用。

  但是，此种开辟新的内存区域然后赋值拷贝的方法在面临指针成员指向的数据量很大时出现效率低下的问题，因此又有下面的处理方法：为指针保留引用计数（reference counting）。
  当类每次拷贝这个指针时，就增加它的计数；对象destroy时检察指针的引用计数，如果为0就删除其指向的资源，否则计数减小。如果指针所指数据相对恒定是，指针引用计数尤为有效。而且在数据量庞大的时候，可以有较高的执行效率。
   类示例代码如下：

 

//一个引用计数器很容易作为一个类来完成
//用于带一个引用计数值得void指针的类
class VoidRefPtr
{
 public:
  //constructor allocates memory for data
  VoidRefPtr(void * pData,int nSize)
  {
   ptr = malloc(nSize);
   memcpy(ptr,pData,nSize);
   nCount = 1;
  }

  //increment the reference count
  VoidRefPtr * Ref()
  {
   nCount ++;
   return this;
  }
  
  //decrement the count and delete if zero
  void Derf()
  {
   if(!--nCount)
    delete this;
  }

 

  ~VoidRefPtr()
  {
   delete ptr
  }
  
  void * ptr()
  {
   return ptr
  }

 private:
  void * ptr;//the data
  unsigned int nCount;//the reference count
 
};

 

//这个类包含了一个实际的指针和用于对引用计数器自加自减的成员函数
//当引用计数器减到零时，对象撤销自身。

class RefcountCharPtr
{
public:
 RefcountCharPtr(const char * pData ="")
 {
  //constructor creates a ref pointer
  pRef = new VoidRefPtr((void *)pData,strlen(pData)+1);
 }

 

 RefcountCharPtr(const RefcountCharPtr &a)
 {
  //copy constructor increments ref count
  pRef = a.pRef->Ref();
 }

 

 ~RefcountCharPtr()
 {
  //destructor decrements ref count
  pRef ->Derf();
 }

 

 const RefcountCharPtr & operator = (const RefcountCharPtr & a)
 {
  //asignment
  //decrement ref count of existing pointer
  pRef->Derf();
  //increment that of assigned pointer
  pRef = a.pRef->Ref();
  return * this;
 }

 

 RefcountCharPtr & operator =(const char * pData)
 {
  //char string assignment
  //decrement ref count of existing pointer
  pRef->Derf();
  //make new pointer
  pRef = new VoidRefPtr((void *)pData,strlen(pData)+1);
  return *this;
 }

 

 //type conversion to a char string
 operator const char * ()
 {
  return (char * )pRef->ptr();
 }

protected:
private:
 VoidRefPtr * pRef;
};

  一个同学给出了一个类似的实现：

   class RefData

{

 public:

  RefData(char *s)

  {

   data = new String(s);

  }

 int refCount;

 String *data;

};

 

class MyString
{
 public:
  MyString(const char *s = "");

 //...
 //...
 private:
  RefData * value; // 私有指针变量
};

 

MyString::MyString(const char *s = ""):value(new RefData(s))
{
}

 

MyString & MyString::operator=(const MyString & str)
{
 if (value == str.value) //如果是自己复制给自己
  return *this;

 if (--(value->refCount) == 0)
  delete value;

 value = s.value; // 只拷贝指针
 ++(value->refCount);
 return *this;
}

 

char & MyString::operator[](int dex) //改变值的时候
{
 if (value->refCount >1)
 {
  --value->refCount;
  value = new RefData(value->data)
 }

 return value->data[index];
}

 

//测试示例
int main()
{
 MyString s1 ="hello";
 char *p = &s1[1];
 MyString s2 = s1;
 *p = 'x';
}

 

  虽然引用计数的处理方法貌似不错，但是其亦存在其弊端：在多线程的条件下，其执行效率尤为低下。具体参见（Herb Shutter的在C++ Report杂志中的Guru专栏以及整理后出版的《More Exceptional C++》中专门的讨论）。
     
  最近在看设计模式的一些东东，偶然又发现了下面的一段：
  下面是一些可以使用Proxy模式的常见情况：
  ...
  4)智能指引（smart reference）--取代了简单的指针，它在访问对象时执行一些附加操作。它的典型用途包括：
   对指向实际对象的引用计数，这样当该对象没有引用时，可以自动释放它（也称为 smartpointers[Ede92]）.
   当第一次引用一个持久对象时，将它装入内存。
   在访问一个实际对象前，检察是否已经锁定了它，以确保其他对象不能改变它。
   以上的叙述的用途好像有些像引用计数，但是具体如何，现在偶还不是很清楚，准备将两者放在一起，看其联系和区别究竟如何。

   以上只是最近在看c++时遇到的一点问题，将其放在一起讨论，希望可以明白其原理和实现。
参考文章：
http://www.vckbase.com/document/viewdoc/?id=846
http://www.w3china.org/blog/more.asp?name=oceanblue&id=6786
http://gengwentao.blogchina.com/
参考书籍：
最优c/c++编程秘诀（The Best c/c++ Tips Ever） Anthony Porter 著 秦冬雷等译
设计模式 GOF

快乐的源泉 2006-07-14 14:43 发表评论