Re: operator class&() { return *this; } considered harmful?

From:

AlbertoBarbati@libero.it (Alberto Ganesh Barbati)

Newsgroups:

comp.std.c++

Date:

Fri, 2 Nov 2007 16:54:13 GMT

Message-ID:

<TLCWi.161350$U01.1150349@twister1.libero.it>

[Note to mods: this is a repost. Although the previous post had been
approved, it somehow didn't appear on the newsgroup.]

Michael Norrish ha scritto:

Alberto Ganesh Barbati wrote:

Michael Norrish ha scritto:

Clearly, the rvalue reference proposal solves all sorts of other
interesting issues apart from the one in my example, but my question
is really whether or not

operator C&() { return *this; }

will safely achieve what I want.

I don't think so. According to my interpretation, 12.2/5 doesn't apply
here, because in line:

C &x = f();

the reference x is *not* bound to a temporary, but rather to the

result

of the call to operator C& which is a reference (such reference
*happens* to be bound to a temporary but this fact is irrelevant to a
strict interpretation of 12.2/5).

I expect the temporary to be properly destroyed at the end of the
full-expression, making x a dangling reference.

If this is so, is there any point to the language in 8.5.3/5 allowing
this? (This language is "if the initializer expression ... has a
class type ... and can be implicitly converted to an lvalue....". The
footnote emphasises that this situation can only arise when you have a
conversion function returning a reference type.)

Notice that in this case "the reference is bound to the lvalue result of
the conversion" confirming my interpretation.

That clause only applies when the initialisor is not an lvalue, so
there will be a temporary here anyway. That temporary can only get
turned into an l-value via a conversion function, but if you are
right, then the conversion function can't usefully return a reference
to the temporary it's called on because that temporary will disappear
as soon as the declaration of the reference completes. (The
conversion function could return a reference to something other than
the temporary of course; some global perhaps).

The fault in your reasoning is that it's not true that the initializer
must be an temporary to trigger this case. Consider this:

  class B;

  class A
  {
  public:
    operator B& ();
  };

  A a;
  B& b = a;

In fact, this example shows a very good reason why this case is allowed.

HTH,

Ganesh

---
[ 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 ]