开发者社区> 异步社区> 正文
阿里云
为了无法计算的价值
打开APP
阿里云APP内打开

《C++面向对象高效编程(第2版)》——3.4 赋值操作符

简介:
+关注继续查看

本节书摘来自异步社区出版社《C++面向对象高效编程(第2版)》一书中的第3章,第3.4节,作者: 【美】Kayshav Dattatri,更多章节内容可以访问云栖社区“异步社区”公众号查看。

3.4 赋值操作符

C++面向对象高效编程(第2版)
现在,让我们分析main程序中的语句:

a = b ;  // 将一个栈赋值给另一个栈
在该语句中,我们将对象b赋值给对象a,使用赋值操作符完成赋值操作。如果a和b都是简单的整数,无论a中的值是什么,编译器都会用b中的值将其擦写(overwrite)。就是这么简单。但是在该例中,a和b都是我们创建的对象,这意味着由我们负责赋值操作。我们知道TIntStack类对象之间如何进行赋值,并且能够实现赋值操作符。对于任何赋值操作符,都应注意以下几点:

(1)确保对象没有自我赋值(如a = a)。

(2)复用被赋值对象中的资源或销毁它。

(3)从源对象中将待复制内容复制到目的对象。

(4)最后,返回对目的对象的引用。

赋值操作符已在类中声明。TIntStack类的赋值操作符签名如下:

TIntStack& operator=(TIntStack& source) // ①
TIntStack& operator=(const TIntStack& source) // ②```
下面是赋值操作符的实现:

TIntStack& TIntStack::operator=(const TIntStack& source)
{
  // 检查自我复制(即a = a)。
  // source是被赋值的对象,&source给出对象source的地址,
  // ‘this’是被赋值对象的地址。
  if (this == &source) {
      cout << “Warning: Assignment to self.n”;
      return *this;
  }
   /*
    如果源对象栈中的元素数目小于或等于目的对象的大小,则没有任何问题。
    我们要做的就是复制栈中相应的元素和_count变量。
    但是,如果源对象栈中元素的数目大于目的对象的大小,则必须先删除目的对象_sp中内存,再为其分配新的内存(与源对象栈中元素的数目相等),然后复制所有元素。
   */
  if (source._count > this->_size) {
     // 源对象中元素的数目大于目的对象的大小,
     // 删除_sp中的内存并重新分配内存。
     // 见下文解释
      delete [] _sp;
      this->_size = source._size;
      _sp = new int [ this->_size ];
  }
    // 无论是小于等于还是大于的情况,都会用到以下代码遍历栈,
    // 并复制元素
    for (int i = 0; i < source._count; i++)
      this->_sp[i] = source._sp[i]; // 复制元素
    this->_count = source._count;
    return *this; // 见下文解释
}`
分析:赋值操作由程序员显式完成,系统(编译器)绝不会直接调用它。赋值是在两个现有对象之间执行的操作。如下语句:
`
a = b;`
当a和b都为对象时,上句可解析为:
`
operator=(b);`
换言之,左侧(left hand side,缩写为LHS)的对象调用成员函数operator=(),右侧(right hand side,缩写为RHS)操作数作为operator=()的参数。赋值操作右侧的对象(该例中为b)不能被修改,该操作的副作用(side effect)是:返回对左侧对象(该例中为a)的引用。因为不能修改右侧的对象(我们只能读取右侧对象并写入左侧对象),所以该对象应作为const实参传递给operator=()函数(如②所示)。然而,如果使用没有const参数的赋值操作符(如①所示),就可以被修改右侧的对象。我们并不推荐使用①这样的赋值操作符,因为类的用户并不希望在赋值操作中改变右侧的对象。由于a和b都是真正的现有对象,因此,将b赋值给a时,a中的值将被b中的值擦写(overwrite)。

记住:

如果我们在类中未提供赋值操作符,编译器会为类生成一个默认赋值操作符(编译器绝不会自动调用它,但确实会生成一个)。但是,这样的默认赋值操作符可能无法满足我们的要求,下一章将对此作详细介绍。

在任何赋值操作中,我们要做的就是将数据从源对象赋值到目的对象。一般而言,这很容易,但在某些情况下会有困难。在TIntStack的示例中,我们需要从源栈赋值到目的栈。如果源栈中的元素数目少于或等于目的栈中的可用空间,赋值操作便非常简单,只需复制相应的栈元素。但是,如果源栈中的元素数目多于目的栈所能持有的数目会怎样?我们不允许这样的操作发生,在打印出错误消息后将从赋值操作返回。不过,这样限制太大。或者,我们可以改变目的栈的大小,使其能容纳所有元素。如果我们接受后者的方案,就需要在目的栈上为源栈的元素分配与源栈大小相等的新内存。这样做之前,我们还要删除目的栈中_sp所指向的现有内存(无法扩展这个内存),这就是上面的赋值操作符中调用delete所完成的任务。一旦完成内存分配,我们就只需要复制相应的元素进栈即可(见图3-3和图3-4)。

(摘自前面的main程序)

TIntStack a(5);  // 自动对象(_auto object_),在退出main时被销毁 
TIntStack b(20);  // 另一个自动对象```
最后,我们返回对目的对象(也就是栈a)的引用。你可能会质疑,为什么要这样做?假设我们编写了一个级联赋值操作(cascaded assignment operation)如下:

`c = a = b; // 将b赋值给a,然后将结果再赋值给c`
赋值操作按从右到左的顺序执行1,此表达式即转换为:

`c = (a = b); // 首先将b赋值给a,然后将结果赋值给c`
警告:
既然可以写“a = b;”,那么也可以写

`a = a;  // 语法上正确,但是逻辑上错误!`
这样的表达式可能会通过指针和引用(别名)直接或间接地发生,我们的实现必须检查是否出现这种情况。因此,必须核实源地址和目的地址是否相同。如果赋值发生在相同的对象之间,则不会进行任何操作,只返回对目的对象的引用。这就是上面示例的实现中,进行自我赋值检查所完成的工作。

如果没有进行自我赋值检查,可能会导致严重问题。考虑以下包含指针数据成员的TString类:

class TString {
    public:
       TString (const char* sp) {
         _data = new char[strlen(sp) + 1];
          strcpy(_data, sp);
       }
       TString & operator=(const TString & assign);
    private:
       char* _data; // 字符串指针
};
TString& TString::operator=(const TString& assign)
{
    // 错误代码,未检查自我赋值  
  delete [] this->_data; // ①
   data = new char[strlen(assign.data) + 1]; // ②
   strcpy(this->_data, assign._data);
   return *this;
}
TString x1(“Text string1”);
x1 = x1;`
以上operator=的实现并不安全,其中的①,删除的是x1._data。接着在②中,我们又试图使用assign._data。因为左侧的对象(*this)与右侧的对象(assign)是同一个对象,即assign._data与x1._data相同。所以,我们搬起石头砸自己的脚。当执行②时,该程序可能崩溃,或者在别的地方出现问题。因此,在赋值操作的实现中,必须进行自我赋值检查。
image

图3-4

将b赋值给a非常简单,之前的示例中已介绍过赋值如何工作。我们希望将赋值(b赋值给a)的结果再赋值给c。为使其正常工作,第1个赋值操作应返回a的值(或对a的引用)。否则,从a到c的第2次赋值就会出问题。通常,在C和C++中,我们只知道使用赋值操作的结果,却并不了解内部的实现。例如,正是因为赋值操作的副作用,才使得以下代码可以正常工作:

int i = 10, j = 20; // 此处无赋值操作
int k;
cout << (i = j) << endl; // 将j赋值给i,并打印赋值结果①。

if (k = j) { // 将j赋值给k,如果结果不为0,执行if体内部的语句②。
   // 省略此处代码
}```
在①中,完成赋值后返回i的值,并打印该值。与此类似,在②中,将j赋值给k,完成赋值后,返回k的值并与0进行比较。

为了让以上赋值都能正常工作,必须确保在赋值操作完成后,该赋值操作返回对a对象的引用。

`Pascal:`

在类似Pacal的语言中,以下的赋值操作没有副作用:

`a := b;`
在赋值后无法返回a的值。因此,以下语句

`c := a := b;`
无法在Pascal(以及类似的语言,如Modula-2)中使用。

思考:

对比复制构造函数和赋值操作符中的代码,会发现很多相似的地方。它们都将现有对象复制到另一个对象中。但是,你能否发现两处代码的主要差别?换言之,复制构造函数和赋值操作符的代码有何区别?能否让它们共享实现?

为完成TIngStack的示例,其余的成员函数实现如下:

void TIntStack::Push(int what)
{
   if (_count < _size) {  // 如有更多空间储存元素
    _sp[_count] = what;  // 储存元素
    _count++;  // 递增count
   }
   else {
    cout << “Stack is FULL. Cannot Push value” << what << endl;
   }
}
int TIntStack::Pop()
{
   if (_count <= 0) { // 栈为空
     cout << “Stack is EMPTYn”;
     exit (1);  // 如果失败如何报错?可在此处抛出异常。
   }
   _count--;
   return _sp[_count];
}
unsigned TIntStack::HowMany() const
{
   return _count;
}`
1此处用到操作符重载和操作符结合律,将在第8章中介绍。在本章讨论中,只需记住赋值从右向左结合。
本文仅用于学习和交流目的,不代表异步社区观点。非商业转载请注明作译者、出处,并保留本文的原始链接。

版权声明:本文内容由阿里云实名注册用户自发贡献,版权归原作者所有,阿里云开发者社区不拥有其著作权,亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容,填写侵权投诉表单进行举报,一经查实,本社区将立刻删除涉嫌侵权内容。

相关文章
+关注
异步社区
异步社区(www.epubit.com)是人民邮电出版社旗下IT专业图书旗舰社区,也是国内领先的IT专业图书社区,致力于优质学习内容的出版和分享,实现了纸书电子书的同步上架,于2015年8月上线运营。公众号【异步图书】,每日赠送异步新书。
文章
问答
文章排行榜
最热
最新
相关电子书
更多
继承与功能组合
立即下载
移动与复制
立即下载
C++课程-对象模型
立即下载