Re: reference to non-const temporary

From:

ee231@cam.ac.uk (Ethan Eade)

Newsgroups:

comp.std.c++

Date:

Fri, 28 Jul 2006 05:21:52 GMT

Message-ID:

<UZKdncorAblS9lTZRVnyhQ@bt.com>

johnchx2@yahoo.com wrote:

It is arbitrary. IIRC, the rule was added to the language because
programmers were getting unexpected results from code like:

  void add_one( long& x ) { x = x + 1; }

  int i = 1;
  add_one( i );
  assert( i == 2 );

It's possible to say, "Well, don't make that mistake." But I gather
that, in real life, programmers *did* make this mistake, often enough
that the "const rule" was added in order to catch it.

That makes sense. But surely the restriction can be limited to
temporaries created by implicit conversion.

As Seungbeom Kim points out above, the rule in its current form merely
encourages ugly use of methods that return a reference to the object:

struct Foo {
    Foo& self() { return *this; }
};

Foo make();
void use(Foo& foo);

int main() {
    use(make().self());
}

That seems silly and pointless. Or the following, which I consider even
worse:

struct Foo {};

template <class T> struct Ref {
    T value;
    Ref(T t) : value(t) {}
    operator T& () { return value; }
};
....
use(Ref<Foo>(make()));

- Ethan

---
[ comp.std.c++ is moderated. To submit articles, try just posting with ]
[ your news-reader. If that fails, use mailto:std-c++@ncar.ucar.edu ]
[ --- Please see the FAQ before posting. --- ]
[ FAQ: http://www.comeaucomputing.com/csc/faq.html ]