Re: function defined with base class return derived class object when called with a derived class
B?RCI Norbert wrote:
SG wrote:
At some point I was actually considering something like this:
class A {
public:
auto foo() -> this;
};
to fix the problem of dangling references in cases like
A const& r = A().foo();
For derived types the return type could be automatically covariant
like you suggested. The return value could even retain its
"valueness" (lvalues -> lvalue, rvalue -> rvalue).
Great!
How about
auto foo( /* parameters */ ) -> decltype( this )
which falls nicely into the current C++0x "new function declarator
syntax" (it currently allows using the ids of the function parameters,
so I see no problem to allow "this" there also).
Either decltype(this) works and refers to A* or A*const (not sure) or
the use of "this" is not legal in this place. But if it is, decltype
(this) refers to a normal type and doesn't convey the information that
the function returns a pointer or reference to *this.
If you are proposing a new type of functions (that convey extra
knowledge about the return value in their signature) you also have to
consider its implications w.r.t. the type system, function pointers,
generic programming, perfect forwarding, etc. From what I can tell
this would introduce a lot of special cases that one has to deal with.
Do you know what the current C++ draft (or pending submissions) say
about what happens upon derivation?
In case the syntax is legal, I'm sure it doesn't do what you want
because decltype(this) is just an expression for a type and equal to
A* or A*const even if you derive class B from A and invoke the member
function on an object of type B.
If the compiler must re-evaluate
the decltype expressions, we are ready... :)
More,
auto foo( /* parameters */ ) -> decltype( expression )
could explicitly define not only the return type, but the return
_value_ also if the function definition does not end with a return
statement. We could consider this as a "default" for the return
statement. If the function body has a return statement, current
semantics applied. (Hmmm, I think it would be rare that the decltype
expression is different than the return statement. Isn't it?)
I don't like the idea. decltype(expression) refers to a type and
nothing more.
Hmmm, I have just flipped through one of the the newest proposition
(Lawrence Crowl, Alisdair Meredith: Unified function syntax (N2890)),
and it has got the following:
"
[] twice(int x) -> auto { return x+x; }
"
Wow! If we substitue, we got:
[] foo( /* parameters */ ) -> auto { /* do it */ return *this; }
As far as I know this proposal has not been accepted. Though, I
appreciate type inference of the return value for "normal" functions.
So, what I would like to see is that "-> type" becomes optional for
inline functions that contain a single return statement, for example:
inline auto func(int x, int y) {return x+y;}
This would be consistent with the lambda feature which also allows the
user to omit the return type in the same case. Personally, I don't
like the [] syntax for anything other than lambdas.
Your /*do it*/, however, turns the function into something that is
more complicated than a single return statement. Also, the return type
is only inferred and doesn't magically change in derived classes if
you write "*this" because "this" is still a pointer to A.
I think you're trying to fix a "problem" which many don't consider a
problem at all. I certainly don't, to be honest.
With the new syntax stated above, is it possible that
[] foo( A & a /* other parameters */ ) -> auto { return a; }
solves it also?
No. It's just the return type that is inferred, nothing more. I can
still use a pointer of type A&(*)(A&) to hold the address of this
function. If you want the signature to convey more information about
the return value you're talking about a different class of function
types. I don't think you can convince anybody to add a new class of
function types because it requires special treatment everywhere.
Cheers!
SG
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]