[021]必须返回对象时,别妄想返回其reference

引言

在条目20中,我们知道了值传递和引用传递的效率问题,因此在设计程序时,我们可能就尽可能来返回引用而不是值。

可是,可能会犯下面的一些错误:传递一些引用指向其实并不存在的对象。

第一节:返回临时变量的引用

假如我们有以下的例子,先看值传递

 1 class A {
 2 public:
 3     A(int n = 0, int d = 1):n(n),d(d) {}
 4 private:
 5     int n,d;
 6     friend const A operator* (const A& l, const A& r);
 7 };

在operator*系以值传递的方式返回了一个计算结果,联系到条款20,我们自然会想到,那么用引用传递试试。

因为函数返回的是A对象,所以函数创建新对象的方式有2:

1.在stack空间创建

1 const A& operator* (const A& l, const A& r) {
2     A result(l.n * r.n, l.d * r.d);
3     return result;
4 }

这样我们避免值传递的调用构造和析构函数,可是result是个临时变量,在函数推出前就被销毁了。任何对这个函数的调用都会是无意义的行为。

2.在heap空间创建

1 const A& operator* (const A& l, const A& r) {
2     A* result = new A(l.n * r.n, l.d * r.d);
3     return *result;
4 }

这样解决了上面临时变量的问题。可是,这个new出来的对象什么时候被释放呢?

就算我们调用A的时候很谨慎,但还是避免不了出错,比如

1 A w,x,y,z;
2 w = x * y * z;     // 实际与operator*(operator*(x, y), z)相同

这里同一个语句例调用了两次operator*,因此两次使用new,也就需要两次delete,但却没有合理的办法让operator*使用者进行那些delete调用。这就会导致资源泄露。

经过上面两种方法都不行,可能你还会想到这种方法:我声明一个static对象不行么?

比如:

1 const A& operator* (const A& l, const A& r) {
2     static A result;
3     result = .....
4     return result;
5 }

看上去完美的解决了这个问题,那么我们这样使用的时候呢?

1 bool operator == (const A& l, const A& r);
2 A a,b,c,d;
3 if ((a*b) == (c*d)) {
4 ....
5 }

结果就会出现:(a*b) == (c*d)总是为true,无论a,b,c,d是什么!

将(a*b) == (c*d)拆开来理解,我们就可以知道为什么了。

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

因为到最后位置,都会返回static对象的现值,也就不怪乎为什么返回true了。

◆总结

1.绝不要返回pointer或者referenc指向一个local stack对象,或返回reference指向一个heap-allocated对象,或返回pointer或reference指向一个local static对象。

时间: 2024-10-02 22:47:17

[021]必须返回对象时,别妄想返回其reference的相关文章

Effective C++:条款21:必须返回对象时别妄想返回其reference

(一) 一定要避免传递一些references去指向其实并不存在的对象. 看下面这个类: class Rational { public: Rational(int numerator = 0, int denominator = 1); private: int n, d; friend const Rational operator*(const Rational& lhs, const Rational& rhs); }; 这个函数不能返回引用, (二)在stack中分配local对

Effective C++ 条款21必须返回对象时,别妄想返回其reference

1. 虽然一般情况下传参使用const-by-reference-to-const比较好,但返回值有时必须是对象而不是引用: 当reference绑定到函数内创建的局部对象时,函数调用结束后引用绑定在一个不存在的对象; 当reference绑定到堆内存对象时,函数调用后比较容易忽略内存释放,特别对于以下表达式:w=x*y*z.如果operator*返回指向堆内存的引用,那没内存泄露是必然的; 当reference绑定到函数内部创建的static对象时,对于以下表达式if(a*b==c*d)由于返

Item 21:需要返回对象时,不要返回引用 Effective C++笔记

Item 21: Don't try to return a reference when you must return an object Item 20中提到,多数情况下传引用比传值更好.追求这一点是好的,但千万别返回空的引用或指针. 一个典型的场景如下: class Rational{ int n, d; public: Raitonal(int numerator=0, int denominator=1); }; // 返回值为什么是const请参考Item 3 friend con

条款21:必须返回对象时,别妄想返回其reference

条款21:必须返回对象时,别妄想返回其reference 引用只是对象的一种别名当使用引用的时候,请确认他的另一个身份在哪? class Rational { public: Rational(int x, int y) : m_x(x), m_y(y){} //返回const是属于类型保护,friend修饰,以后条款详说 friend const Rational operator + (const Rational &lhs, const Rational &rhs) { Ration

条款23: 必须返回一个对象时不要试图返回一个引用

class rational { public: rational(int numerator = 0, int denominator = 1); ... private: int n, d; // 分子和分母 friend const rational // 参见条款21:为什么 operator*(const rational& lhs, // 返回值是const const rational& rhs) }; inline const rational operator*(cons

条款21: 必须返回对象时,别妄想返回其reference

总结: 绝不要返回一个local栈对象的指针或引用:绝不要返回一个被分配的堆对象的引用:绝不要返回一个局部对象有可能同时需要多个这样的对象的指针或引用. 条款4中给出了“在单线程环境中合理返回局部静态对象的引用” 提出问题 一旦程序员抓住对象传值的效率隐忧,很多人就会一心一意根除传值的罪恶.他们不屈不挠地追求传引用的纯度,但他们全都犯了一个致命的错误:传递不存在的对象的引用.考虑一个用以表现有理数的类,包含一个函数计算两个有理数的乘积: class Rational { public: Rati

原则21:必须返回对象时,别妄想返回其引用

http://www.jianshu.com/p/35f26eea6cb3 Effective C++中第21个原则,因为引用是要指向某已存在的对象的,但如果该对象某一瞬间突然消失了,这个引用被架空了,那就出错了.为了证实这一点作者举了一个有理数相乘的例子.有这个一个有理数类,其中有一个有理数相乘的成员函数,该成员函数返回该有理数类的对象.在此例中该对象是一个本地对象,什么叫本地对象呢?就是一个普通的,局部的对象,它随着作用域的结束而被自动销毁.因为具备这一性质,一旦你把这个函数的返回值赋给某一

Effective C++ -----条款21:必须返回对象时,别妄想返回其reference

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

读书笔记_Effective_C++_条款二十一:当必须返回对象时,别妄想返回其reference

在栈空间的临时成员变量在函数生命期结束后无法传出 friend A& operator*(const A& a, const A& b) { A temp; temp.data = a.data*b.data;//a,b的成员变量相乘 return temp; } 既然栈空间不行,试试堆空间 friend A& operator*(const A& a, const A& b) { A *temp=new A; temp.data = a.data*b.da