大学IT网 - 最懂大学生的IT学习网站! QQ资料交流群:367606806
当前位置:大学IT网 > C++技巧 > C++必须返回对象时别返回引用

C++必须返回对象时别返回引用

关键词:C++引用  阅读(526) 赞(12)

[摘要]本文主要是对C++必须返回对象时别返回引用的讲解,希望对您学习C++有所帮助!
 一旦顺序员抓住对象传值的效率隐忧,很多人就会成为狂热的圣战分子,誓要根除传值的罪恶,无论它隐藏多深。他们锲而不舍地追求传引用的纯度,但他们全都犯了一个致命的错误:他们末尾传递并不存在的对象的引用。这可不是什么好事。

  思索一个代表有理数的类,包括一个将两个有理数相乘的函数:

class Rational {
 public:
  Rational(int numerator = 0, // see Item 24 for why this
  int denominator = 1); // ctor isn’t declared explicit
  ...

 private:
  int n, d; // numerator and denominator

 friend:
  const Rational // see Item 3 for why the
  operator*(const Rational& lhs, // return type is const
  const Rational& rhs);
};

operator* 的这个版本以传值方式前往它的结果,而且假定你没有担忧那个对象的构造和析构的代价,你就是在推脱你的专业职责。假定你不是何乐不为,你不应该为这样的一个对象付出本钱。所以效果就在这里:你是何乐不为吗?

哦,假定你能用前往一个引用来作为替代,你就不是何乐不为。但是,请记住一个引用仅仅是一个名字,一个理论存在的对象的名字。无论何时只需你看到一个引用的声明,你应该立刻问自己它是什么东西的另一个名字,由于它一定是某物的另一个名字。在这个 operator* 的情况下,假定函数前往一个引用,它必需前往某个已存在的而且其中包括两个对象相乘的产物的 Rational 对象的引用。

当然没有什么理由希冀这样一个对象在调用 operator* 之前就存在。也就是说,假定你有

Rational a(1, 2); // a = 1/2
Rational b(3, 5); // b = 3/5

Rational c = a * b; // c should be 3/10

似乎没有理由希冀那里碰巧已经存在一个值为十分之三的有理数。不是这样的,假定 operator* 前往这样一个数的引用,它必需自己创建那个数字对象。

一个函数创建一个新对象仅有两种方法:在栈上或许在堆上。栈上的生成物经过定义一个局部变量而生成。运用这个战略,你可以用这种方法试写 operator*:

const Rational& operator*(const Rational& lhs, // warning! bad code!
const Rational& rhs)
{
 Rational result(lhs.n * rhs.n, lhs.d * rhs.d);
 return result;
}

你可以立即否决这种方法,由于你的目的是避免调用构造函数,而 result 正像任何其它对象一样必需被构造。一个更严重的效果是这个函数前往一个引向 result 的引用,但是 result 是一个局部对象,而局部对象在函数参与时被销毁。那么,这个 operator* 的版本不会前往引向一个 Rational 的引用——它前往引向一个前 Rational;一个曾经的 Rational;一个空泛的、恶臭的、腐败的,从前是一个 Rational 但永不再是的尸体的引用,由于它已经被销毁了。任何调用者甚至于没有来得及匆匆看一眼这个函数的前往值就立刻进入了未定义行为的领地。这是理想,任何前往一个引向局部变量的引用的函数都是错误的。(关于任何前往一个指向局部变量的指针的函数异常成立。)

那么,让我们思索一下在堆上构造一个对象并前往引向它的引用的可以性。基于堆的对象经过运用 new 而末尾存在,所以你可以像这样写一个基于堆的 operator*:

const Rational& operator*(const Rational& lhs, // warning! more bad
const Rational& rhs) // code!
{
 Rational *result = new Rational(lhs.n * rhs.n, lhs.d * rhs.d);
 return *result;
}

哦,你还是必需求付出一个构造函数调用的本钱,由于经过 new 分配的内存要经过调用一个适当的构造函数中止初始化,但是如今你有另一个效果:谁是删除你用 new 做出来的对象的适合人选?

即使调用者渎职尽责且一心向善,它们也不太可以是用这样的方案来合理地预防透露:

Rational w, x, y, z;

w = x * y * z; // same as operator*(operator*(x, y), z)

这里,在同一个语句中有两个 operator* 的调用,因此 new 被运用了两次,这两次都需求运用 delete 来销毁。但是 operator* 的客户没有合理的办法中止那些调用,由于他们没有合理的办法取得隐藏在经过调用 operator* 前往的引用后面的指针。这是一个早已注定的资源透露。

但是也许你留意到无论是在栈上的还是在堆上的方法,为了从 operator* 前往的每一个 result,我们都不得不容忍一次构造函数的调用。也许你想起我们最初的目的是避免这样的构造函数调用。也许你以为你知道一种方法能避免除一次以外几乎全部的构造函数调用。也许下面这个完成是你做过的,一个基于 operator* 前往一个引向 static Rational 对象的引用的完成,而这个 static Rational 对象定义在函数内部:

const Rational& operator*(const Rational& lhs, // warning! yet more
const Rational& rhs) // bad code!
{
 static Rational result; // static object to which a
 // reference will be returned

 result = ... ; // multiply lhs by rhs and put the
 // product inside result
 return result;
}

就像一切运用了 static 对象的设计一样,这个也会立即惹起我们的线程安全(thread-safety)的混乱,但那是它的比较清楚的缺陷。为了看到它的更深层的缺陷,思索这个完全合理的客户代码:

bool operator==(const Rational& lhs, // an operator==
const Rational& rhs); // for Rationals

Rational a, b, c, d;

...
if ((a * b) == (c * d)) {
 do whatever’s appropriate when the products are equal;
} else {
 do whatever’s appropriate when they’re not;
}

猜猜会怎样样?不管 a,b,c,d 的值是什么,表达式 ((a*b) == (c*d)) 总是等于 true!

假定代码重写为功用完全等价的另一种方式,这一启示就很容易被理解了:

if (operator==(operator*(a, b), operator*(c, d)))

留意,当 operator== 被调用时,将同时存在两个起作用的对 operator* 的调用,每一个都将前往引向 operator* 内部的 static Rational 对象的引用。因此,operator== 将被要求比较 operator* 内部的 static Rational 对象的值和 operator* 内部的 static Rational 对象的值。假定它们不是永远相等,那才真的会令人心惊胆战了。

这些应该足够让你信服试图从类似 operator* 这样的函数中前往一个引用地道是糜费时间,但是你们中的某些人可以会这样想“好吧,就算一个 static 不够用,也许一个 static 的数组是一个窍门……”

我无法拿出示例代码来一定这个设计,但我可以概要说明为什么这个想法应该让你羞愧得无地自容。首先,你必需选择一个 n 作为数组的大小。假定 n 太小,你可以会用完存储函数前往值的空间,与刚刚名誉扫地的 single-static 设计相比,在任何一个方面你都不会失掉更多的东西。但是假定 n 太大,就会降低你的顺序的功用,由于在函数第一次被调用的时分数组中的每一个对象都会被构造。即使这个我们正在讨论的函数仅被调用了一次,也将让你付出 n 个构造函数和 n 个析构函数的本钱。假定“优化”是提高软件效率的进程,关于这种东西也只能是“绝望主义”的。最后,思索你怎样将你所需求的值放入数组的对象中,以及你做这些需求付出什么。在两个对象间移动值的最直接方法就是经过赋值,但是一次赋值将要付出什么?关于很多类型,这就大约相当于调用一次析构函数(销毁原来的值)加上调用一次构造函数(把新值拷贝过去)。但是你的目的是避免付出构造和析构本钱!面对的结果就是:这个方法绝对不会成功。(不,用一个 vector 替代数组也不会让事情有多少改进。)

写一个必需前往一个新对象的函数的正确方法就是让那个函数前往一个新对象。关于 Rational 的 operator*,这就意味着下面这些代码或在本质上与其相当的某些东西:

inline const Rational operator*(const Rational& lhs, const Rational& rhs)
{
 return Rational(lhs.n * rhs.n, lhs.d * rhs.d);
}

当然,你可以付出了却构和析构 operator* 的前往值的本钱,但是从长远看,这只是为正确行为付出的很小的代价。除此之外,这种令你感到恐惧的账单也许永远都不会抵达。就像一切的顺序设计言语,C++ 允许编译器的完成者在不改动生成代码的可观察行为的条件下运用优化来提升它的功用,在某些条件下会发作如下结果:operator* 的前往值的构造和析构能被安全地消弭。假定编译器运用了这一点(编译器经常这样做),你的顺序还是在它假定的方法上继续运转,只是比你等候的要快。 全部的焦点在这里:假定需求在前往一个引用和前往一个对象之间做出决议,你的义务就是让那个选择能提供正确的行为。让你的编译器厂商去绞尽脑汁使那个选择尽可以地廉价。

Things to Remember

·绝不要前往一个局部栈对象的指针或引用,绝不要前往一个被分配的堆对象的引用,假定存在需求一个以上这样的对象的可以性时,绝不要前往一个局部 static 对象的指针或引用。



相关评论