If you want that to mean that you can pass any type to the function, make it a template: template <typename T> int function(T data); There’s a proposal for C++17 to allow the syntax you used (as C++14 already does for generic lambdas), but it’s not standard yet. Edit: C++ 2020 now supports auto function … Read more
To make long story short: a braced initializer expression {} has no type by itself auto has to infer type information int{3} obviously means “create an int var with value taken from initializer list”, thus its type is just int and can be used in any wider context (int i = int{3} will work and … Read more
By using auto&& var = <initializer> you are saying: I will accept any initializer regardless of whether it is an lvalue or rvalue expression and I will preserve its constness. This is typically used for forwarding (usually with T&&). The reason this works is because a “universal reference”, auto&& or T&&, will bind to anything. … Read more
The template <auto> feature (P0127R1) was accepted into C++ in the ISO C++ 2016 meeting in Oulu, Finland. An auto keyword in a template parameter can be used to indicate a non-type parameter the type of which is deduced at the point of instantiation. It helps to think of this as a more convenient way … 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
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
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
Return type forwarding in generic code For non-generic code, like the initial example you gave, you can manually select to get a reference as a return type: auto const& Example(int const& i) { return i; } but in generic code you want to be able to perfectly forward a return type without knowing whether you … Read more
I think that one should use the auto keyword whenever it’s hard to say how to write the type at first sight, but the type of the right hand side of an expression is obvious. For example, using: my_multi_type::nth_index<2>::type::key_type::composite_key_type:: key_extractor_tuple::tail_type::head_type::result_type to get the composite key type in boost::multi_index, even though you know that it is … 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