Taken from the C++0x FDIS (n3290):
If a lambda-expression does not include a lambda-declarator, it is as if the lambda-declarator were (). If a lambda-expression does not include a trailing-return-type, it is as if the trailing-return-type denotes the following type:
- if the compound-statement is of the form
{ attribute-specifier-seqopt return expression ; }
the type of the returned expression after lvalue-to-rvalue conversion (4.1), array-to-pointer conversion (4.2), and function-to-pointer conversion (4.3);- otherwise, void.
Why doesn't the standard allow the compiler to analyse the compound-statement and determine the return type based on the first found return
statement?
I can't see any reason to not allow this, but maybe I'm overlooking something.
Example:
int main(){
// compiler: nope.jpg
auto l = []{
// one computation
// another computation
// yet another one!
return something;
}
}
Edit: Please no "because the standard says so" answers. :)
There's no technical reason for this. IIRC it was already implemented by the GCC C++ maintainer and he said it's trivial to implement.
The committee is very conservative about accepting features into the Standard so they went with this simple form of deduction and will later hopefully accept a more powerful form. See the reason for rejection on US 30 comment.
DR 975 is already marked "ready" so chances are good it will be accepted.
Why doesn't the standard allow the compiler to analyse the compound-statement and determine the return type based on the first found return statement?
In my opinion, reasons are inheritance, implicit typecast to void*
and 0
typecasted to int
, which makes it difficult for compiler implementers to deduce type from the first return
statement.
See the below examples:
// "B" is a derived by "D"
int main(){
auto l = []{
return (D*)(...); // should it be "D*" (derived)
// computation
return (B*)(...); // no it should be "B*" (base)
}
}
Second,
int main(){
auto l = []{
return (int*)(...); // should it be "int*"
// computation
return (void*)(...); // no it has to be "void*"
}
}
Third one,
int main(){
auto l = []{
return 0; // should it be "int"
// computation
return (double)(...); // no it has to be "double"
}
}
Also there is one more reason related to giving a compilation error message, when two unrelated return
are found:
int main(){
auto l = []{
return TYPE1;
// computation
return TYPE2;
}
}
Now, question would arise that what useful compiler message should be printed to user ? The error message has to be only for one of the return
statements. Which return
to choose ?
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With