《Effective C++》学习笔记——条款21

最新推荐文章于 2022-12-01 10:46:08 发布

ltree98

最新推荐文章于 2022-12-01 10:46:08 发布

阅读量966

点赞数

分类专栏： Effective C++ 文章标签： Effective C++ 学习笔记条款21

本文链接：https://blog.csdn.net/lttree/article/details/41981479

版权

Effective C++ 专栏收录该内容

45 篇文章 5 订阅

订阅专栏

***************************************转载请注明出处：http://blog.csdn.net/lttree********************************************

四、Designs and Declarations

Rule 21：Don't try to return a reference when you must return an object

规则 21：必须返回对象时，别妄想返回其reference

1.原因

看了我们条款20 ，如果领悟了 pass-by-value 的效率牵连层面，或许就恨不得都用 pass-by-reference 来替代。但这时，可能会出现一些致命的错误——开始传递一些指向其实并不存在的的对象。

先来看一下这个例子，这是一个表现有理数的类。

<span style="font-family:Comic Sans MS;">class Rational  {
public:
    Rational( int numerator = 0 , int denominator = 1 );
    ...
private:
    int n,d;    // n 为分子，d 为分母
    friend const Rational operator* ( const Rational& lhs, const Rational& rhs);
};</span>

这里的 operator* 用 by value 方式返回其计算结果，但会有额外的开销，当然你也可以完全不管，但这明显逃避了你的专业责任，因为很简单的，改而传递 reference 就不需要支付额外代价。

但是，要记住所谓的 reference 只是个名称，代表某个既有对象。所以如果看到一个reference声明式，你应该问自己它的另一个名称是什么。

以上述 operator* 为例，如果它返回一个 reference，后者一定指向某个既有的Rational 对象，内含两个 Rational对象的乘积。

但是，我们无法期望这样的一个 Rational对象在调用 operator* 之前就存在。

所以，如果 operator* 要返回一个 reference 指向如此数值，它必须自己创建那个 Rational对象。

2.解决

>1< 通过函数创建新对象。

函数创建新对象的途径有两种：在stack空间或在 heap 空间创建。

① 在stack空间创建

就是定义一个 local 变量，用这方法来写 operator* ：

<span style="font-family:Comic Sans MS;">const Rational& operator* ( const Rational& lhs, const Rational& rhs)
{
    Rational result( lhs.n * rhs.n , lhs.d * rhs.d );    // 糟糕的代码
    return result;
}</span>

这种做法不好，因为你的目标是避免调用构造函数，而 result 却必须像任何对象一样的由构造函数够早起来。

但更严重的是，这个函数返回的reference是 local对象，而local对象在函数退出前就会被销毁。也就是说，reference 指向的是一个已经被销毁的对象。

② 在 heap内构造一个对象

Heap-based对象由 new 创建，所以它的 operator* :

<span style="font-family:Comic Sans MS;">const Rational& operator* ( const Rational& lhs, const Rational& rhs)
{
    Rational* result = new Rational( lhs.n * rhs.n,lhs.d * rhs.d );
    return *result;
}</span>

但是这个依旧需要付出一个调用构造函数的代价，

而且这又有一个新的问题：谁该对着被你 new 出来的对象执行 delete。

尤其是，遇到下面这段代码：

<span style="font-family:Comic Sans MS;">Rational w,x,y,z;
w = x * y *z;    // 等价于 operator*(operator*(x,y),z)</span>

在这里同一个语句内，调用了两个 operator* ，也就是说 new 了两次，即要 delete两次。

但是这里却没有合理的方法让 operator* 使用者进行这些 delete 的调用，因为没有合理的方法来获取 operator* 返回的references背后隐藏的指针。

这些都将导致资源泄露！

>2< 让 operator* 返回的reference 指向一个被定义于函数内部 static 对象

因为上述，无论 on-the-stack 或 on-the-heap做法，都因为对 operator* 返回的结果调用构造函数而困扰，所以可以尝试这种方法。

<span style="font-family:Comic Sans MS;">const Rational& operator* ( const Rational& lhs, const Rational& rhs )
{
    static Rational result;
    result = ...;
    return result;
}</span>

但是，如果遇到下面这种代码：

<span style="font-family:Comic Sans MS;">bool operator==( const Rational& lhs,const  Rational& rhs);    // 针对Rational而写的 operator==
Rational a,b,c,d;
...
if( (a*b) == (c*d) )
{
    // 当乘积相等，做适当动作
}
else
{
    // 当乘积不等，做相应动作
}</span>

每次判断（a*b）==（c*d）都将会是 true！

Why？因为两次operator* 虽然都各自改变了 static Rantional 对象值。但由于它们返回的都是 reference ，因此调用端看到的永远是 static Rantional对象的 "现值"!

>扩展如果static Rantional 对象不行，那....static array 怎么样？

首先，你必须选择 array 大小n。如果n太小，那空间可能不够；如果n太大，会因此降低程序效率，因为array内的每一个对象都会在第一次被调用时构造完成。

如果上面这个无法说服你，那下面这个理由呢？如何将你需要的值放进array内。如果那么做成本又是多少。即使以vector替换array也不会让情况好转。

>3< 正确答案该出来了

让那个函数返回一个新对象。

<span style="font-family:Comic Sans MS;font-size:12px;">inline const Rantional operator* ( const Rational& lhs,const Rational& rhs )
{
    return Rational(lhs.n*rhs.n,lhs.d*rhs.d);
}</span>

当然这么做，需要承担 operator* 返回值的构造和析构的成本。

但是要知道，C++和所有编程语言一样，允许编译器实现者施行最优化，用以改善产出码的效率。因此某些情况下，这些成本可以被安全的消除。

所以，当你必须在"返回一个reference和返回一个object"之间抉择时，你的工作就是挑出行为正确的那一个。然后让编译器厂商做剩余的东西吧。

3.请记住

★绝不要返回 pointer 或 reference 指向一个 local stack 对象，或返回 reference 指向一个 heap-allocated 对象，或返回 pointer 或 reference 指向一个local static 对象而有可能同时需要多个这样的对象。条款4已经为 "在单线程环境中合理返回reference指向一个local static对象"提供了一份设计实例。

**************************************转载请注明出处：http://blog.csdn.net/lttree********************************************