[Effective C++ --028]避免返回handles指向对象内部成分

假设程序涉及矩形。每个矩形由其左上角和右下角表示。为了让Rectangle对象尽可能小,可能把定义矩形的点放在一个辅助的struct内再让Rectangle去指它:

 1 class Point {                      // 得到坐标
 2 public:
 3     Point(int x, int y) {};
 4     void setX(int newVal) {};
 5     void setY(int newVal) {};
 6 };
 7
 8 struct RectData
 9 {
10     Point ulhc;
11     Point lrhc;
12 };
13
14 class Rectangle {
15 public:
16     Rectangle(Point p1, Point p2) {};
17     Point& upperLeft() const {
18         return pData->ulhc;
19     }
20     Point& lowerRight() const {
21         return pData->lrhc;
22     }
23 private:
24     std::tr1::shared_ptr<RectData> pData;
25 };

这样的设计可以通过编译,但却是错误的。实际上自相矛盾,一方面upperleft和lowerRight被声明为const,不让客户修改Rectangle。另一方面,这两个函数都返回reference指向private数据,调用者可以通过这些reference更改内部数据:

1     Point c1(0, 0);
2     Point c2(100, 100);
3
4     const Rectangle rec(c1, c2);
5     rec.upperLeft().setX(10);           // 现在rec变成从(50,0)到(100,100)

这里需要注意:upperLeft的调用者能够使用被返回的reference(指向rec内部的Point成员变量)来更改成员。但rec其实应该是不可变的(const)!

第一,成员变量的封装性最多只等于“返回其reference”的函数的访问级别。

第二,如果const成员函数传出一个reference,后者所指数据与对象自身有关,而它又被存储在对象之外,那么这个函数的调用者可以修改那笔数据。这正是bitwise constness的一个附带结果,条款3。

如果它们返回的是指针或迭代器,相同的结果还会发生,原因相同。reference、指针和迭代器统统都是所谓的handles(号码牌,用来取得某个对象),而返回一个“代表对象内部数据的handle”,随之而来的便是“降低对象封装性”的风险。同时,也可能造成“虽然调用const成员函数却造成对象状态被更改”。

通常我们认为,对象的“内部”就是指它的成员变量,其实不被公开使用的成员函数(protected或private)也是对象“内部”的一部分,所以也不该返回它们的handles。否则,它们的访问级别就会提高到返回它们的成员函数的访问级别。

上述两个问题可以在它们的返回类型上加上const即可:

 1 class Rectangle {
 2 public:
 3     Rectangle(Point p1, Point p2) {};
 4     const Point& upperLeft() const {
 5         return pData->ulhc;
 6     }
 7     const Point& lowerRight() const {
 8         return pData->lrhc;
 9     }
10 private:
11     std::tr1::shared_ptr<RectData> pData;
12 };

即使这样,返回“代表对象内部”的handles,有可能在其他场合导致dangling handles(空悬的号码牌):这种handle所指东西(的所属对象)不复存在。这种“不复存在的对象”最常见的来源就是函数返回值。例如某个函数返回GUI对象的外框,这个外框采用矩形形式:

1 class GUIObject{...};
2 const Rectangle boundingBox(const GUIObject& obj);

现在,客户有可能这么使用这个函数:

1 GUIObject *pgo;
2 ...
3 const Point* pUpperLeft = &(boundingBox(*pgo).upperLeft());    //取得一个指针指向外框左上点

对boundingBox的调用获得一个新的、暂时的Rectangle对象,这个对象没有名称,权且称它为temp。随后upperLeft作用于temp对象身上,返回reference指向temp的一个内部成分。具体指向temp的那个Point对象。但是这个语句结束之后,boundingBox的返回值,也就是我们所说的temp,将被销毁,而那间接导致temp内的Points析构。最终导致pUpperLeft指向一个不再存在的对象,变成空悬、虚吊(dangling)!

只要handle被传出去了,不管这个handle是不是const,也不论返回handle的函数是不是const。这里的唯一关键是暴露在“handle比其所指对象更长寿”的风险下。

◆总结

1.避免返回handles(包括reference、指针、迭代器)指向对象内部。遵守这个条款可增加封装性,帮助const成员函数的行为像个const,并将发生"虚吊号码牌(dangling handles)"的可能性降至最低。

时间: 2024-10-25 07:18:58

[Effective C++ --028]避免返回handles指向对象内部成分的相关文章

Effective C++ 条款28 避免返回handles指向对象内部成分

1. 所谓的handles指的是引用,指针,迭代器(可能与windows的句柄有所区别),返回一个handles会导致提供给用户对象内部数据的间接访问,这降低了成员变量的封装性,例如: class Demo{ public: ... int* getPtr() const { return ptr; } private: ... int* ptr; } 这段代码语法正确,但是它违背了将getPtr设为const的初衷:从语法上来说ptr所指对象也属于Demo对象的一部分,但从语法上讲,由于编译器

Effective C++:条款28:避免返回 handles 指向对象内部成员

(一) 有时候为了让一个对象尽量小,可以把数据放在另外一个辅助的struct中,然后再让一个类去指向它.看下面的代码: class Point { public: Point(int x, int y); void setX(int newVal); void setY(int newVal); }; struct RectData { Point ulhc; Point lrhc; }; class Rectangle { public: Point& upperLeft() const {

条款28:避免返回handles指向对象的内部成分。

首先看看下面这个例子: 1 class Point{ 2 public: 3 point(int x, int y); 4 ... 5 void setX(int newVal); 6 void setY(int newVal); 7 ... 8 }; 9 struct RectData{ 10 Point ulhc; //左上角 11 Point lrhc; //右下角 12 }; 13 class Rectangle{ 14 ... 15 private: 16 shared_ptr<Rec

Effective C++ Item 28 避免返回对象内部数据的引用或指针

本文为senlie原创.转载请保留此地址:http://blog.csdn.net/zhengsenlie Item 31 经验:避免返回handles(包含 references.指针.迭代器)指向对象内部.遵守这个条款可添加封装性, 帮助 const 成员函数的行为像个 const,并将发生"虚吊号码牌"(dangling handles)的可能性降至最低. 演示样例: class Point{ public: Point(int x, int y); //... void set

指向对象的引用置空---与内存泄漏

import java.util.Arrays; public class Stack { private static final int INIT_SIZE = 10; private Object[] datas; private int size; public Stack() { super(); datas = new Object[INIT_SIZE]; } public void push(Object data){ if (size == datas.length) { ext

Effective Item 3 - 避免不必要的对象

通常,我们更喜欢重用一个对象而不是重新创建一个. 如果对象是不可变的,它就始终可以被重用. 下面是一个反面例子,Joshua Bloch明确指出[DON'T TO THIS]: String s = new String("stringette"); 该语句每次执行时都创建一个新的实例. String构造器中的参数"stringette"本身是一个实例,功能方面等同于那些通过构造器创建的对象. 如果这种语句放到循环里,效果会变得更糟. 于是我们只需要: String

php学习笔记之指向对象的变量

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/1999/xhtml"> <head> <meta http-equiv="Content-

基类中定义的虚函数在派生类中重新定义时,其函数原型,包括返回类型、函数名、参数个数、参数类型及参数的先后顺序,都必须与基类中的原型完全相同 but------&gt; 可以返回派生类对象的引用或指针

您查询的关键词是:c++primer习题15.25 以下是该网页在北京时间 2016年07月15日 02:57:08 的快照: 如果打开速度慢,可以尝试快速版:如果想更新或删除快照,可以投诉快照. 百度和网页 http://bbs.csdn.net/topics/380238133 的作者无关,不对其内容负责.百度快照谨为网络故障时之索引,不代表被搜索网站的即时页面. 首页 精选版块 移动开发 iOS Android Qt WP 云计算 IaaS Pass/SaaS 分布式计算/Hadoop J

Effective Java读书笔记(3对于所有对象都通用的方法)

3.1 覆盖equals时请遵守通用约定 什么时候应该覆盖Object.equals()方法呢? 如果类具有自己特有的"逻辑相等"概念(不同于对象等同的概念),而且超类还没有覆盖equals以实现期望的行为,这时我们就需要覆盖equals方法. Object.equals()方法具有自反性.对称性.传递性.一致性和与null比较返回false的特点. 实现高质量equals方法的诀窍: (1)使用==操作符检查"参数是否为这个对象的引用".如果是,则返回true,这