CSDN博客

img cwizard

由一份auto_ptr源代码所引发的思考

发表于2003/4/30 11:12:00  576人阅读

由一份auto_ptr源代码所引发的思考
                               Kyle

                        CPPCN 版权所有
如果我问你,auto_ptr最关键的地方,或者说它与一般指针最不一样的地方在哪里,你一定会说它是一个对象,它与自己所占有的资源密切相关,当自己消亡的时候,它也会将自己所拥有的资源一同释放。很好,它之所以会拥有这一特性,全都要归于析构函数的功劳,在析构函数中,它会进行善后处理,这样也就很好的避免了资源泄漏。当然,引入auto_ptr的原因还不至于这么简单,因为许多资源泄漏的问题主要是由于我们的粗心大意所致,所以只要我们细心一些,还是会避免一些不该发生的资源泄漏问题。那究竟是什么原因让我们引入auto_ptr呢?对了,你一定也想到了,就是在异常处理的时候。Ok,来看下面这个例子:
void foo()
{
 ClassA *ptr=new ClassA;
 try
 {
/*  此处放置可能抛出异常的操作 */
 }
 catch(…)
 {
   delete ptr;
   throw;
 }
 delete ptr;
}
上面这个例子使用了一般的指针,你会发现它防止发生资源泄漏的处理是多么复杂,必须在每个catch中进行资源的释放,而且有可能会有许多的catch。天哪,这简直就是灾难,它会使我们的代码很长,不易维护,如果忘记其中的一个,就会产生莫名其妙的错误。既然一般的指针防止资源泄漏会如此的繁琐,那有没有一个办法可以使我们不必操心资源的释放呢,由于在异常发生的时候,会进行堆栈解退,所以我们不必担心作为局部变量的指针本身不被销毁,既然这样,我们干脆建立一个指针对象,好比下面这样:
template<class T>
class auto_ptr1
{
private:
 T* ap;
public:
   ……..
 ~auto_ptr(); //资源释放
}
当指针被销毁的时候,必然会执行析构函数,那就在析构函数中进行资源的释放不就ok了,呵呵,怎么样,是不是很简单呢?的确,整个逻辑的确很简单,但是如果我们在深入思考一下这个指针对象的特性的话,我们会发现有一个困难的问题等待我们去解决。那下面就让我们来看看会遇到什么困难。
   由于在auto_ptr销毁的时候它会自动通过析构函数释放所拥有的资源,那么也就决定了auto_ptr对于资源的独占性,即一个资源只能被一个auto_ptr所指向。这一点应该很好理解,假设有两个auto_ptr指向同一个资源,那当其中一个被销毁的时候,另一个将会指向哪里呢?这种指针往往是最为危险的。既然这样,我们怎样才能保证这种独占性呢,其实也很简单,当对指针进行赋值和复制的时候,剥夺原有指针对资源的拥有权,问题也就迎韧而解了。就好比这样:
 auto_ptr<int> p(new int(20));
 auto_ptr<int> q;
 q=p;  //p已经丧失了对资源的拥有权,q现在是p的主人

对于这种一般性的情况,问题似乎已经解决了,下面让我们来看一种特殊但却合理的情况:

auto_ptr<int> foo()
{
 auto_ptr<int> p(new int(20));
 return p;
}
int main()
{
 auto_ptr<int> q(foo());
 return 0;
}
你认为上面这种情况怎么样,它是合理的,因为它实现了资源的顺利移交,但是你认为auto_ptr<int> q(foo());这一句应该怎样才能调用成功呢?为了说清这个问题,还需要说说左值和右值以及临时对象的问题。也许你会说左值应该就是能够改变的变量,右值当然就是不能改变的变量喽!对吗?对了一点点,实际上左值是能够被引用的变量,说的通俗点就是有名字的变量,你一定想到了些什么,对了,临时变量就没有名字,即使有你也不会知道,因为它不是由你创建的,编译器会在内部辨别它,但你并不知道,因此临时变量不是左值,而是右值。你也许还会问,那const变量是不是左值呢?根据定义,它有名字,当然就是左值了。因此左值并非一定“可被修改”。但是左值和右值与参数有什么关系吗?我要告诉你的是:有,而且相当密切,因为标准c++规定:若传递给类型为引用的形参的实参是右值的话必须保证形参为const引用。Ok,现在让我们回到原来的问题上,由于foo()按值返回,因此编译器必然会产生一个临时对象,也就是说 auto_ptr<int> q(foo()); 这一句中q的构造函数传入的参数是一个右值,因此若想让这一句成功的调用,它的原型必须是这样的:auto_ptr(const auto_ptr&); 但是这样行吗?显然是不行的,因为我们还要剥夺原有指针对资源的拥有权呢,如果采用const引用,那是无法进行剥夺的,因为你无法修改它。你也许想到了另一个办法,我们只要用mutable修饰核心数据域的话,那么即使它是const也可以进行修改它的核心数据。这个办法看起来似乎不错,但如果我们在考虑一下下面这种情况,你或许会改变你的看法,假设有一个const auto_ptr ,如果我们把它赋值给另一个auto_ptr的话,你说应该是怎样的情况发生,呵呵,当然应该是禁止了,因为你不应该试图去改变一个const对象,即禁止剥夺一个const auto_ptr对资源的拥有权。但是如果按照你的想法,采用mutable的话,这种改变是可以实现的,因此你应该打消采用mutable的念头。那么难道就没有办法了吗?当然有,但是不太容易想到,请看下面这个简单的例子:

class X
{
private:
 int value;
public:
 X(int v=0)
 {
 value=v;
 }
 X(X& a)
 {
 value=a.value;
 a.value=0;
 }
 int set(int v)
 {
 value=v;
 return value;
 }
 friend ostream& operator << (ostream& os, const X& x)
 {
 os<<x.value<<endl;
 }
};

X f()
{
 X a(100);
 return a;
}

int main()
{
 X c(f());
 cout<<c;
 return 0;
}
上面这个例子和我们所遇到的情况有些相似X c(f());这一句是无法调用成功的,而且也不能把复制构造函数的引用参数变为const,因为我们要修改参数。Ok,我们就利用这个简单的例子来解决我们所遇到的问题。既然我们已经想到的一些方案不能达到我们的目的,那我们怎么做呢,对了,我们可以用类型转换函数。下面让我来帮你整理一下思路:
1.我们首先应该先定义一个类型转换层,它的核心数据应该和X的核心数据一样,例如:
struct Y
{
 int val;
 Y(int v):val(v){}
};
有了这个转换层,我们就可以先把函数f()返回时所生成的临时对象通过一个从X到Y的转换函数转型到Y。然后再通过一个从Y到X的转换函数进行对象的构造。至此,所有问题都得以解决。下面让我们来看一下具体方法。
2.添加一个从X到Y的类型转换函数。如下:
operator Y()
{
 Y y(value);
 return y;
}
3.添加一个从Y到X的类型转换函数,即只有一个参数的构造函数。

X(Y a)
{
 value=a.val;
}
OK,大功告成,你可以把这个例子在你的编译器上实现,果然能够解决所有的问题(在VC上会有一点问题,因为VC在临时对象这一点上对标准C++的支持不够好,用临时对象作参数的时候不加const也可以编译通过),下面我给出auto_ptr的一个实作范例,我想你应该能够理解它了:)

template<class Y>
struct auto_ptr_ref
{
 Y* yp;
 auto_ptr_ref(Y* rhs):yp(rhs){}
};  //注意这个转换层

template<class T>
class auto_ptr1
{
private:
 T* ap;
public:
 typedef T element_type;

 explicit auto_ptr1(T* ptr=0) throw():ap(ptr){}

 auto_ptr1(auto_ptr1& rhs) throw():ap(rhs.release()){}

 template<class Y>
 auto_ptr1(auto_ptr1<Y>& rhs) throw():ap(rhs.release()){}

 auto_ptr1& operator = (auto_ptr1& rhs) throw()
 {
   reset(rhs.release());
   return *this;
 }

 template<class Y>
 auto_ptr1& operator = (auto_ptr1<Y>& rhs) throw()
 {
   reset(rhs.release());
   return *this;
 }

 ~auto_ptr1() throw()
 {
   delete ap;
 }

 T* get() const throw()
 {
   return ap;
 }

 T& operator *() const throw()
 {
   return *ap;
 }

 T* operator ->() const throw()
 {
   return ap;
 }

 T* release() throw()
 {
   T* tmp(ap);
   ap=0;
   return tmp;
 }

  void reset(T* ptr=0) throw()
 {
 if(ap!=ptr)
 {
   delete ap;
   ap=ptr;
 }
 }

 auto_ptr1(auto_ptr_ref<T> rhs) throw():ap(rhs.yp){}

 auto_ptr1& operator = (auto_ptr_ref<T> rhs) throw()
 {
   reset(rhs.yp);
   return *this;
 }

  template<class Y>
 operator auto_ptr_ref<Y>() throw()
 {
   return auto_ptr_ref<Y>(release());
 }

 template<class Y>
 operator auto_ptr1<Y>() throw()
 {
   return auto_ptr1<Y>(release());
 }
};

好了,今天就说到这吧,大家有什么问题可以提出

0 0

相关博文

我的热门文章

img
取 消
img