bart@videovax.tv.Tek.com (Bart Massey) (08/10/89)
My biggest beef with NRVs is that I've used them in Pascal and really hated
them there -- it's really nice for the compiler to be able to warn you that
your function may fall off the end without returning a value, and most
Pascal compilers aren't that smart. It just so happens that I'm the only
programmer in the world dumb enough to forget to return a value from a
function, but... :-) :-)
Of course, as Doug Lea commented, the situation is different in C++, where
you will return something that is properly constructed instead of random
garbage if you fall off the end by accident. But it's not clear that this
is better from a correctness point of view -- the compiler now has no idea
whether you meant to fall off the end or not, and thus *should not* warn
about it. In fact, it's worse than that, since you may have altered the
object but left it in the "wrong" state before falling off.
I guess I've always sort of thought of the C/lint requirement of an explicit
return value at end-of-function as an assertion that I, the programmer,
haven't forgotten about that important case, and kind of liked it for that
reason. NRVs as currently implemented seem to me to break that model.
I guess what I would like is to allow NRVs, but still require the explicit
return statement. If the return value happens to be the NRV, then the
compiler may optimize that case. Any other return value is treated as
usual. To use Doug Lea's example,
X iota_nrv() return x // x is the name of the X we may be returning
{
if( Xsize == -1 ) { // some special case
X *y;
magic_construct( y ); // some magic construction
return *y; // return a copy via X(X&)
}
for (int i=0; i<Xsize; ++i) // fill it up & get out
x.set(i, i); // the NRV is special
return x; // and doesn't need to be copied and constructed
}
This has at least three important benefits, the first of which I've already
talked about. The second is illustrated by the special case above. The
third is that one can trivially convert the above code for a C++ compiler
which doesn't support NRVs, at some loss in efficiency, since the function
body proper may remain identical.
If the special case above were too much trouble, I would be satisfied with
specifying that all returns from a function with NRV "x" would be of the form
"return x;", and this would still provide the other two benefits mentioned
above.
No flames please! If I've obviously bungled, please wait a few days for
someone else to correct me first :-). But questions and comments are
welcome, and I'd be glad to summarize any e-mail I get.
Bart Massey
..tektronix!videovax.tv.tek.com!bart