auto newvar1 = myvector; // vs: auto *newvar2 = myvector; Both of these are the same and will declare a pointer to std::vector<MyClass> (pointing to random location, since myvector is uninitialized in your example and likely contains garbage). So basically you can use any one of them. I would prefer auto var = getVector(), but … Read more
For the same purpose as for arguments: so when Func::operator() is a ref-qualified: struct Functor { void operator ()() const & { std::cout << “lvalue functor\n”; } void operator ()() const && { std::cout << “rvalue functor\n”; } }; Demo
A Lambda may be converted to a function pointer using the unary + operator like so: +[]{return true;} so long as the capture group is empty and it doesn’t have auto arguments.1 If you do this, you may assign different lambdas to the same variable as long as the lambdas all have the same signature. … Read more
This is [dcl.spec.auto/11]: If the type of an entity with an undeduced placeholder type is needed to determine the type of 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 function, … 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
I think the place you are stumbling is actually with the expression c.getObj() in the line return c.getObj();. You think the expression c.getObj() has type const Int&. However that is not true; expressions never have reference type. As noted by Kerrek SB in comments, we sometimes talk about expressions as if they had reference type, … Read more
It’s disallowed by the language: [C++11: 7.1.6.4]: 1 The auto type-specifier signifies that the type of a variable being declared shall be deduced from its initializer or that a function declarator shall include a trailing-return-type. 2 The auto type-specifier may appear with a function declarator with a trailing-return-type (8.3.5) in any context where such a … Read more
This syntax is valid in the C++ Concepts Technical Specification, but not in C++20. In C++20 concepts, auto is only permitted at the top level in a function parameter type. The relevant rule is [dcl.spec.auto] paragraph 2: A placeholder-type-specifier of the form type-constraint[opt] auto can be used as a decl-specifier of the decl-specifier-seq of a … Read more
In this example, they mean the exact same thing. However, there are a few advantages to using the trailing return type form consistently (Phil Nash calls these “East End Functions”, since the return type is on the east end). Using parameters. Obviously when using parameters to determine the return type, you must use a trailing … 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