“自我赋值”发生在对象被赋值给自己时:

1 class Widget {...};
2 Widget w;
3 ...
4 w = w; //赋值给自己

这看起来有点愚蠢,但它合法,所以不要认定客户绝不会那么做。此外赋值动作并不总是那么可被一眼辨认出来,例如:

a[i] = a[j];   //潜在的自我赋值

如果i和j有相同的值,这便是个自我赋值。再看:

*px = *py;   //潜在的自我赋值

如果*px和*py恰好指向同一个东西,这也是自我赋值。这写并不明显的自我赋值,是“别名”带来的结果:所谓“别名”就是“有一个以上的方法指称(指涉)某对象”。一般而言如果某段代码操作pointers或references而它们被用来“指向多个相同类型的对象”,就需要考虑这些对象是否为同一个。实际上两个对象只要来自同一个继承体系,它们甚至不需要声明为相同类型就可能造成“别名”,因为一个base class的reference或pointer可以指向一个derived class对象:

1 class Base { ... };
2 class Derived: public Base {...};
3 void doSomething(const Base& rb, Derived* pd); //rb和*pd有可能其实是同一对象。

如果遵循条款13和条款14的忠告,你会运用对象来管理资源,而且你可以确定所谓“资源管理对象”在copy发生时有正确的举措。这种情况下你的赋值操作符或许是“自我赋值安全的”,不需要额外操心。然而如果你尝试自行管理资源(如果你打算写一个用于资源管理的class就得这样做),可能会掉进“在停止使用资源之前意外释放了它”的陷阱。假设你建立一个class用来保存一个指针指向一块动态分配的位图(bitmap):

1 class Bitmap { ... };
2 class Widget {
3   ...
4 private:
5   Bitmap* pb;     //指针,指向一个从heap分配而得的对象
6 };

下面是operator=实现代码,表面上看起来合理,但是自我赋值出现时并不安全(它也不具备异常安全性,但我们稍后才讨论这个主题)。

1 Widget& Widget::operator=(const Widget& rhs) //一份不安全的operator=实现版本。
2 {
3   delete pb;                                 //停止使用当前的bitmap
4   pb = new Bitmap(*rhs.pb);                  //使用rhs's bitmap的副本(复件)。
5   return *this;                              //见条款10.
6 }

这里的自我赋值问题是,operator=函数内的*this(赋值的目的端)和rhs有可能是同一个对象。果真如此delete就不只是销毁当前对象的bitmap,它也销毁rhs的bitmap。在函数末尾,Widget——它原本不该被自我赋值动作改变的——发现自己持有一个指针指向一个已被删除的对象!

欲阻止这种错误,传统做法是由operator=最前面的一个“证同测试”达到“自我赋值”的检验目的:

1 Widget& Widget::operator=(const Widget& rhs)
2 {
3   if(this == &rhs) return *this;   //证同测试:如果是自我赋值就不做任何事。

5   delete pb;
6   pb = new Bitmap(*rhs.pb);
7   return *this;
8 }

这样做行得通。稍早我曾经提过,前一版operator=不仅不具备“自我赋值安全性”,也不具备“异常安全性”,这个新版本仍然存在异常方面的麻烦。更明确地说,如果"new Bitmap”导致异常(不论是因为分配时内存不足或因为Bitmap的copy构造函数抛出异常),Widget最终会持有一个指针指向一块被删除的Bitmap。这样的指针有害。你无法安全地删除它们,甚至无法安全地读取它们。唯一能对它们做的安全事情就是付出许多调试能量找出错误的起源。

令人高兴的是,让operator=具备“异常安全性”往往自动获得“自我赋值安全”的回报。因此愈来愈多人对“自我赋值”的处理态度是倾向不去管它,把焦点放在实现“异常安全性”上。条款29深度探讨了异常安全性,本条款只要你注意“许多时候一群精心安排的语句就可以导出异常安全(以及自我赋值安全)的代码”,这就够了。例如以下代码,我们只需注意在复制pb所指东西之前别删除pb:

1 Widget& Widget::operator=(const Widget& rhs)
2 {
3   Bitmap* pOrig = pb;         //记住原先的pb
4   pb = new Bitmap(*rhs.pb);   //令pb指向*pb的一个复件(副本)
5   delete pOrig;               //删除原先的pb
6   return *this;
7 }

现在,如果“new Bitmap”抛出异常,pb(及其栖身的那个Widget)保持原状。即使没有证同测试,这段代码还是能够处理自我赋值,因为我们对原bitmap做了一份复件、删除原bitmap、然后指向新制造的那个复件。它或许不是处理“自我赋值”的最高效办法,但它行得通。

如果你很关心效率,可以把“证同测试”再次放回函数起始处。然而这样做之前先问问自己,你估计“自我赋值”的发生频率有多高?因为这项测试也需要成本。它会使代码变大一些(包括原始码和目标码)并导入一个新的控制流分支,而两者都会降低执行速度。Prefetching、caching和pipelining的指令的效率都会因此降低。

在operator=函数内手工排列语句(确保代码不但“异常安全”而且“自我赋值安全”)的一个替代方案是,使用所谓的copy and swap技术。这个技术和“异常安全性”有密切关系,所以由条款29详细说明。然而由于它是一个常见而够好的operator=撰写办法,所以值得看看其实现手法像什么样子:

 1 class Widget {
 2   ...
 3   void swap(Widget& rhs);  //交换*this和rhs的数据:详见条款29
 4   ...
 5 };
 6 Widget& Widget::operator=(const Widget& rhs)
 7 {
 8   Widget temp(rhs);       //为rhs数据制作一份复件(副本)
 9   swap(temp);             //将*this数据和上述复件的数据交换。
10   return *this;
11 }

这个主题的另一个变奏曲乃利用以下事实:(1)某class的copy assignment操作符可能被声明为“以by value方式接受实参”;(2)以by vlaue方式传递东西会造成一份复件/副本(见条款20):

1 Widget& Widget::operator=(Widget rhs)  //rhs是被传对象的一份复件(副本),注意这里是pass by value。
2 {
3   swap(rhs);                           //将*this的数据和复件/副本的数据互换
4   return *this;
5 }

我个人比较忧虑这个做法,我认为它为了伶俐巧妙的修补而牺牲了清晰性。然而将“copy 动作”从函数本体内移至“函数参数构造阶段”却可令编译器有时生成更高效的代码。

请记住:

1、确保当对象自我赋值时operator=有良好行为。其中技术包括比较“来源对象”和“目标对象”的地址、精心周到的语句顺序、以及copy-and-swap。

2、确定任何函数如果操作一个以上的对象,而其中多个对象是同一个对象时,其行为仍然正确。

转载于:https://www.cnblogs.com/shengjin/archive/2010/01/31/1657899.html

Effective C++ 11 在operator=中处理“自我赋值” 笔记相关推荐

  1. 条款11 在operator=中处理“自我赋值”

    "自我赋值"发生在对象被赋值给自己时: 1 class Widget {...}; 2 Widget w; 3 ... 4 w = w; //赋值给自己 这看起来有点愚蠢,但它合法 ...

  2. Effective C++ 条款11:在operator=中处理自我赋值

    "自我赋值"发生在对象被赋值给自己时: class Widget { ... }; Widget w; ... w = w; // 赋值给自己 a[i] = a[j]; // 潜在 ...

  3. 条款11:在operator=中处理“自我赋值”

    什么是自我赋值,就是 v = v 这种类型的语句,也许很多人都会说鄙视这种写法,但是如下的写法会不会出现呢? 比如:a[i] = a[j];      // 不巧的是i可能和j相等 *px = *py ...

  4. EC笔记:第二部分:11:在operator=中处理“自我赋值”

    已经一年半没有写过博客了,最近发现学过的知识还是需要整理一下,为知笔记,要开始收费了以前写在为知笔记上笔记也会慢慢的转到博客里. 话不多说,进入正题. 考虑考虑以下场景: 当某个对象对自身赋值时,会出 ...

  5. C++尽量在operater=中处理“自我赋值”

    operater=中处理"自我赋值 下面的operator=实现是一份不安全的实现,在自赋值时会出现问题: 1.在开头添加"证同测试" c++ 2.通过确保异常安全来获得 ...

  6. Effective C++ 中文版(第三版)读书笔记 更新ing~

    Effective C++ 中文版(第三版)持续更新ing 让自己习惯C++ 条款1 视c++为一个联邦 条款2 尽量以const,enum,inline替换#define 条款3 尽可能使用cons ...

  7. 声明及赋值_重述《Effective C++》二——构造、析构、赋值运算

    关于本专栏,请看为什么写这个专栏.如果你想阅读带有条款目录的文章,欢迎访问我的主页. 构造和析构一方面是对象的诞生和终结:另一方面,它们也意味着资源的开辟和归还.这些操作犯错误会导致深远的后果--你需 ...

  8. effective C++ 条款 11:在operator= 处理‘自我赋值’

    假设建立一个class来保存一个指针指向一块儿动态分配的位图(bitmap) class Bitmap{...}; class Widget { public: protected: private: ...

  9. 在operator =中要处理“自我赋值”

    防止自我赋值很有必要 Widget w; w = w; a[i] = a[j]; //a[i]和a[j]实际上指向同一个元素 *pi = *pj; //pi和pj实际上指向同一个元素 自我赋值的危害: ...

最新文章

  1. javascript高级程序设计之面向对象的程序设计
  2. Spring3中js/css/jpg/gif等静态资源无法找到(No mapping found for HTTP request with URI)问题解决...
  3. 扫描线三巨头 hdu1928hdu 1255 hdu 1542 [POJ 1151]
  4. 触发full gc的条件
  5. 模板 · ISAP网络流+GAP优化+弧优化
  6. 【Oracle】ORA-38171: Insufficient privileges for SQL management object operation
  7. Linux逻辑盘卷管理LVM
  8. Spring Boot 整合 Kafka 分布式消息系统快速入门
  9. 智慧环保综合解决方案
  10. 未来房价涨or跌?大数据告诉你
  11. MulterError: Unexpected field
  12. 【转】关于PCI和PCIE
  13. iEx.ec——云计算业务的区块链革命
  14. 前端RSA加密,加密字符串过长,提示“Message too long for RSA”问题
  15. 九龙证券|美国散户疯狂抄底,嗅到了什么?华尔街最新警告
  16. AbortController-中止请求
  17. 少说话多写代码之Python学习017——字典的方法(items、pop)
  18. 搭建服务器 运用阿里云DNS自己实现DDNS
  19. Houdini和Touchdesigner中实现场力与弹力的相互作用
  20. ERP售前史话:本土财务软件前世今生

热门文章

  1. c4d支持mac系统渲染器有哪些_C4D常用的4大主流渲染器如何选择与比较 (OC/RS/VR/阿诺德)...
  2. python 图片base64 编解码,转换成Opencv,PIL.Image图片格式
  3. 数组去重(包括es6)
  4. opengl中gpu与cpu交互_OpenGL 环境配置与教程推荐
  5. python 如果你的年龄大于18_python基础
  6. 数据结构实验之数组二:稀疏矩阵
  7. 由创建一个不能被继承的类引发的对象模型的思考
  8. 如何解决没有文件扩展“.js”的脚本引擎
  9. Java程序员从笨鸟到菜鸟之(五)java开发常用类(包装,数字处理集合等)(下)
  10. 第二章 反向传播算法如何工作的?