There are certain cases where you must use a trailing return type. Most notably, a lambda return type, if specified, must be specified via a trailing return type. Also, if your return type utilizes a decltype that requires that the argument names are in scope, a trailing return type must be used (however, one can … Read more
I think when the type is very well-known amongst the co-programmers who work (or would work) in your project, then auto can be used, such as in the following code: //good : auto increases readability here for(auto it = v.begin(); it != v.end(); ++it) //v is some [std] container { //.. } Or, more generally, … Read more
auto and auto && cover most of the cases: Use auto when you need a local copy. This will never produce a reference. The copy (or move) constructor must exist, but it might not get called, due to the copy elision optimization. Use auto && when you don’t care if the object is local or … Read more
auto is an old C keyword that means “local scope”. auto a is the same as auto int a, and because local scope is the default for a variable declared inside a function, it’s also the same as int a in this example. This keyword is actually a leftover from C’s predecessor B, where there … Read more
The program is ill-formed (clang is right) per [dcl.spec.auto]/9: If the name of an entity with an undeduced placeholder type appears in an expression, the program is ill-formed. Once a non-discarded return statement has been seen in a function, however, the return type deduced from that statement can be used in the rest of the … Read more
Generic lambdas were introduced in C++14. Simply, the closure type defined by the lambda expression will have a templated call operator rather than the regular, non-template call operator of C++11‘s lambdas (of course, when auto appears at least once in the parameter list). So your example: auto glambda = [] (auto a) { return a; … Read more
The rules for auto are, for the most part, the same as for template type deduction. The example posted works for the same reason you can pass objects of private types to template functions: template <typename T> void fun(T t) {} int main() { Foo f; fun(f.Baz()); // ok } And why can we pass … Read more
The question is about drawbacks of auto, so this answer highlights some of those. A drawback of using a programming language feature (in this case, a facility associated with a language keyword) does not mean that feature is unacceptable, nor does it mean that feature should be avoided entirely. It means there are disadvantages along … Read more
Might be Java 10 has what you (and I) want, through the var keyword. var list = new ArrayList<String>(); // infers ArrayList<String> var stream = list.stream(); // infers Stream<String> From JDK Enhancement Proposals 286 Update: Yap, that feature made it into the Java 10 release!
The type of a lambda expression is unspecified. But they are generally mere syntactic sugar for functors. A lambda is translated directly into a functor. Anything inside the [] are turned into constructor parameters and members of the functor object, and the parameters inside () are turned into parameters for the functor’s operator(). A lambda … Read more