在operator=中检查给自己赋值的情况

在operator=中检查给自己赋值的情况

做类似下面的事时，就会发生自己给自己赋值的情况：

class x { ... };

x a;

a = a;                     // a赋值给自己

这种事做起来好象很无聊，但它完全是合法的，所以看到程序员这样做不要感到丝

毫的怀疑。更重要的是，给自己赋值的情况还可以以下面这种看起来更隐蔽的形式

出现：

a = b;

如果b是a的另一个名字（例如，已被初始化为a的引用），那这也是对自己赋值，

虽然表面上看起来不象。这是别名的一个例子：同一个对象有两个以上的名字。在

本条款的最后将会看到，别名可以以大量任意形式的伪装出现，所以在写函数时一

定要时时考虑到它。

在赋值运算符中要特别注意可能出现别名的情况，其理由基于两点。其中之一是效

率。如果可以在赋值运算符函数体的首部检测到是给自己赋值，就可以立即返回，

从而可以节省大量的工作，否则必须去实现整个赋值操作。例如，条款16指出，一

个正确的派生类的赋值运算符必须调用它的每个基类的的赋值运算符，所以在派生

类中省略赋值运算符函数体的操作将会避免大量对其他函数的调用。

另一个更重要的原因是保证正确性。一个赋值运算符必须首先释放掉一个对象的资

源（去掉旧值），然后根据新值分配新的资源。在自己给自己赋值的情况下，释放

旧的资源将是灾难性的，因为在分配新的资源时会需要旧的资源。

看看下面string对象的赋值，赋值运算符没有对给自己赋值的情况进行检查：

class string {
public:
  string(const char *value);    // 函数定义参见条款11
                                //

  ~string();                    // 函数定义参见条款11
                                //
  ...

  string& operator=(const string& rhs);

private:
  char *data;
};

// 忽略了给自己赋值的情况
// 的赋值运算符
string& string::operator=(const string& rhs)
{
  delete [] data;    // delete old memory

  // 分配新内存，将rhs的值拷贝给它
  data = new char[strlen(rhs.data) + 1];
  strcpy(data, rhs.data);

  return *this;      // see item 15
}

看看下面这种情况将会发生什么：

string a = "hello";

a = a;               // same as a.operator=(a)

赋值运算符内部，*this和rhs好象是不同的对象，但在现在这种情况下它们却恰巧

是同一个对象的不同名字。可以这样来表示这种情况：

*this  data ------------> "hello\0"
                  /
                 /
rhs    data -----

赋值运算符做的第一件事是用delete删除data，其结果将如下所示：

*this  data ------------> ???
                   /
                  /
rhs    data -----

现在，当赋值运算符对rhs.data调用strlen时，结果将无法确定。这是因为data被

删除的时候rhs.data也被删除了，data，this->data 和rhs.data 其实都是同一个

指针！从这一点看，情况只会越变越糟糕。

现在可以知道，解决问题的方案是对可能发生的自己给自己赋值的情况先进行检查

，如果有这种情况就立即返回。不幸的是，这种检查说起来容易做起来难，因为你

必须定义两个对象怎么样才算是“相同”的。

你面临的这个问题学术上称为object identity，它在面向对象领域是个很有名的

论题。本书不是讲述object identity的地方，但有必要提到两个解决这个问题的

基本方法。

一个方法是，如果两个对象具有相同的值，就说它们是相同的（具有相同的身份）

。例如，两个string对象如果都表示的是相同顺序的字符序列，它们就是相同的：

string a = "hello";
string b = "world";
string c = "hello";

a和c具有相同值，所以它们被认为是完全相同的；b和它们都不同。如果把这个定

义用到string类中，赋值运算符看起来就象这样：

string& string::operator=(const string& rhs)
{
  if (strcmp(data, rhs.data) == 0) return *this;

  ...

}

值相等通常由operator==来检测，所以对于一个用值相等来检测对象身份的类c来

说，它的赋值运算符的一般形式是：

c& c::operator=(const c& rhs)
{
  // 检查对自己赋值的情况
  if (*this == rhs)            // 假设operator=存在
    return *this;

  ...

}

注意这个函数比较的是对象（通过operator=），而不是指针。用值相等来确定对

象身份和两个对象是否占用相同的内存没有关系；有关系的只是它们所表示的值。

另一个确定对象身份是否相同的方法是用内存地址。采用这个定义，两个对象当且

仅当它们具有相同的地址时才是相同的。这个定义在c++程序中运用更广泛，可能

是因为它很容易实现而且计算很快，而采用值相等的定义则不一定总具有这两个优

点。采用地址相等的定义，一个普通的赋值运算符看起来象这样：

c& c::operator=(const c& rhs)
{
  // 检查对自己赋值的情况
  if (this == &rhs) return *this;

  ...

}

它对很多程序都适用。

如果需要一个更复杂的机制来确定两个对象是否相同，这就要靠程序员自己来实现

。最普通的方法是实现一个返回某种对象标识符的成员函数：

class c {
public:
  objectid identity() const;    // 参见条款36

  ...

};

对于两个对象指针a和b，当且仅当 a->identity() == b->identity()的时候，它

们所指的对象是完全相同的。当然，必须自己来实现objectids的operator==。

别名和object identity的问题不仅仅局限在operator=里。在任何一个用到的函数

里都可能会遇到。在用到引用和指针的场合，任何两个兼容类型的对象名称都可能

指的是同一个对象。下面列出的是别名出现的其它情形：

class base {
  void mf1(base& rb);          // rb和*this可能相同                     
  ...

};

void f1(base& rb1,base& rb2);  // rb1和rb2可能相同
                               //

class derived: public base {
  void mf2(base& rb);          // rb和*this可能相同
                               //
  ...

};

int f2(derived& rd, base& rb); // rd和rb可能相同
                               //

这些例子刚好都用的是引用，指针也一样。

可以看到，别名可以以各种形式出现，所以决不要忘记它或期望自己永远不会碰到

它。也许你不会碰到，但我们大多数会碰到。而很明显的一条是，处理它会达到事

半功倍的效果。所以任何时候写一个函数，只要别名有可能出现，就必须在写代码

时进行处理。