CSDN博客

img wtong

三位一体

发表于2003/6/17 10:40:00  879人阅读

分类: C++

 

三位一体

Trinity是英文中比较有名的一个单词,在西语神学中表示三个分开的人合为一体,圣父、圣子、圣神合成一神。在C++中也有这样一个Trinity,它们最好一起出现,来尽量避免可能的错误。那就是复制构造函数(copy constructor)、赋值运算符(operator=)和析构函数(destructor)。它们三个要么同时出现,要么同时消失【注1】。如果你从来没有听说过这个提法的话,可以参考2001.6月的《C/C++ Users Journal》中Andrew Koenig and Barbara E. Moo写的《C++ Made Easier: The Rule of Three》。

1:世事总有例外,什么也不是绝对的,一般来说,拥有复制操作(copy constructor, assignment operator)的同时要带上析构函数(destructor),但反之,拥有析构函数并不一定要有复制操作。

对于作为基类(base class)的析构函数,如果这个基类有多态删除的运用,则析构函数应该public virtual,不具有多态删除运用,则析构函数应该protected non-virtual

一般来说这是因为类的构造、拷贝、析构会分配和释放资源。但这不是今天我要讲的重点,下面从上面文章中摘录的代码说明了一切。

//有错误的代码

// This class contains a subtle error
class IntVec {
public:
   IntVec(int n): data(new int[n]) { }
   ~IntVec() { delete[] data; };
   int& operator[](int n)
      { return data[n]; }
   const int& operator[](int n) const
      { return data[n]; }
private:
   int* data;
};

//暴力修正,绝对禁止复制

// This class corrects the error
// by brute force
class IntVec {
public:
   IntVec(int n): data(new int[n]) { }
   ~IntVec() { delete[] data; };
   int& operator[](int n)
      { return data[n]; }
   const int& operator[](int n) const
      { return data[n]; }
private:
   int* data;
   // these two member functions added
   IntVec(const IntVec&);
   IntVec& operator=(const IntVec&);
};

//修正好的,加上了复制操作

// This class corrects the error by
// defining copying and assignment
class IntVec {
public:
   IntVec(int n): data(new int[n]), size(n) { }
   ~IntVec() { delete[] data; };
   int& operator[](int n)
      { return data[n]; }
   const int& operator[](int n) const
      { return data[n]; }
   IntVec(const IntVec& v):
      data(new int[v.size]),
      size(v.size) {
      std::copy(data, data + size, v.data);
   }
   IntVec&
   operator=(const IntVec& v) {
      int* newdata = new int[v.size];
      std::copy(v.data,v.data+v.size, newdata);
      delete[] data;
      data = newdata;
      size = v.size;
      return *this;
   }
private:
   int* data;
   int size;

};

这种一般的三位一体必须首先领会。

如果为了异常安全(exception safety)用到pimpl手法【注2】。其中会用到智能指针auto_ptr

2:可以参考Herb Sutter的《More Exceptional C++》的条款22“异常安全与类的设计”,pimpl手法最先应该出现在《Exceptional C++》中,不过我没有这本书,读者可以自己去参考相关条款。手法pimpl本身很简单,实质就是将类的实现(class implementation)隐藏,然后用一个外包类的auto_ptr指向它。

在这里借用《MEC》中Page144Cargill Widget例子。

class Widget
{
public:
  Widget();  // initializes pimpl_ with new WidgetImpl
  ~Widget(); // must be provided, because the implicit
       //  version causes usage problems
       //  (see Items 30 and 31)
  Widget& operator=( const Widget& );
  // ...
  private:
class WidgetImpl;     
auto_ptr<WidgetImpl> pimpl_;
    // ... provide copy construction that
    //     works correctly, or suppress it ...
};
// Then, typically in a separate
// implementation file:
//
class Widget::WidgetImpl
{
public:
  // ...
  T1 t1_;
  T2 t2_;
};

auto_ptr的目的就是为了自动管理内存资源,上面的类只有一个数据成员(data memberpimpl_,所以按道理是不需要用到析构函数的。自动生成的析构函数已经足够。

但是我们往往观于浊水而迷于清渊。请注意上面析构函数的解释“析构函数必须被提供,隐式生成的版本会引起使用问题”。到底是什么使用问题?书上的解释是:“如果使用编译器自动生成的析构函数,那个析构函数将被定义在每个编译单元(translation unit)中,因而,WidgetImpl的定义必须在每个编译单元可见。”

这个解释闪烁其词,语焉不详。我记得第一次看到的时候就很疑惑,后来用了一个下午的时间差不多弄明白了。

在这个类的设计中,copy constructorassignment operator的提供显而易见,为了资源的正常转移,不用我多说。但是即使析构函数为空,也要提供它,为什么?

为了更好的隐藏信息,简单的回答。一般来说,我们自己设计类的时候,会将类的声明界面和具体实现分别用.h.cpp文件实现。分别编译,别的文件用到这个类的时候,就只需要包含它的.h头文件,而不用管.cpp实现文件,连接(link)的时候自然会找到。这样的模块化(model)设计在C/C++语言中用的极为频繁,很好的达到了界面(一组服务)和实现(服务功能的完成)的分离。

上面例子中class Widget::WidgetImpl的定义肯定在一个单独的文件中,就像它的名字,是为了实现,并不需要被客户(client)所看到。

如果我们为class Widget提供了析构函数,即使它即为空也是内联(inline),我们编译而成的代码中还是有它作为函数存在的位置。但是相反,我们如果没有定义析构函数,则会在用到【注3】这个析构函数的文件中才就地(in palce)生成一个析构函数;如果多个文件中用到这个析构函数,则会在多个文件中分别生成这样一个析构函数,就像《Matrix II》中浴火重生的Agent Smith一样:)

3:注意一定要用到,如果是像老式的C struct一样的Value类型,即一般的POD结构(plain old data struct),析构函数是不会用到的,它当然也不会被生成出来。但是这里的成员数据(member data)是一个auto_ptr<WidgetImpl>,它有不可忽视的(nontrivial)析构函数,所以宿主类型Widget的析构函数也不可忽视。用到的时候就必须被生成出来。

我们现在面对的问题就在这里。分两种情况讨论:

1.对于正常有定义的析构函数,在用到这个析构函数的文件中,会真正的去调用(call)它,就像调用普通的成员函数一样,而不会自己生成。这个文件肯定会包含这个类的.h声明文件,当然文件里面会有这个类析构函数的声明(declaration),然后会在编译完成后的连接(link)阶段由连接器(linker)确定成员函数地址(当然也包括析构函数),为了以后在运行的时候动态调用它。

2.但是对于没有声明和定义的析构函数,即需要靠编译器来生成,上面已经说的很清楚,在用到的文件中就地生成,因为它没有一个固定的位置,所以你即使包含了这个类的.h声明文件,也不可能在连接的时候会有析构函数的地址(它不存在)。在上面的例子中,由于Widget的成员数据auto_ptr<WidgetImpl>析构的时候需要用到WidgetImpl类的定义,所以为了生成合适的Widget函数,则必须知道WidgetImpl的完整定义,所以WidgetImpl的完整定义必须在Widget.h声明文件中,而本身WidgetImpl是一种跟实现相关的信息,一般会放在一个单独的文件中,所以在这里如果你不想写析构函数的话,你就必须暴露WidgetImpl的实现。

整个推导过程,关键就是要认真想一想C++程序的编译和连接过程,在加上一点点编译原理的知识,就能够豁然开朗。

结论:你还是必须明确的写出析构函数,即使它为空,否则你就必须付出暴露实现的代价,这个代价似乎太高了点:)

对于类本身有资源分配与释放的情况,不论是类本身,还是由类的成员数据(member data)来控制,绝大部分情况我们都必须为其提供copy constructorassignment operator(或者有时候会明确禁止它们),同时就必须提供析构函数。

所以我们的古老原则三位一体(Trinity)即使在出现智能指针的情况下,即使在析构函数为空的情况下,仍然应该遵守。

吴桐写于2003.5.31

最近修改2003.6.16

0 0

相关博文

我的热门文章

img
取 消
img