You can, but you have to declare it static and const: struct Timer { static const auto start = 0; }; A working example in Coliru. With this limitation, you therefore cannot have start as a non-static member, and cannot have different values in different objects. If you want different types of start for different … Read more
It’s because you declare b to be a pointer, and initialize it to be a null pointer. But a null pointer to what type of data you don’t say, so the compiler can’t deduce the type. If you want b to be a std::nullptr_t object, you should drop the asterisk: auto b{nullptr};
That’s the simplest and most clear way to write it: template <typename F> auto invoke_log_return(F&& f) { auto result = f(); std::printf(” …logging here… %s\n”, result.foo()); return result; } The GCC gets the right (no needless copies or moves) expected result: s() in main prvalue s() …logging here… Foo! lvalue s(const s&) …logging here… Foo! … Read more
The rationale that you included is reasonably clear: naturally, virtual functions are meant to be overridden by subclasses, so you as the designer of the base class should make it as easy as possible for people who inherit your class to provide a suitable override. However, if you use auto, figuring out the return type … Read more
Based on the following, GCC has the right behaviour in this case, but only by coincidence (see below): ยง7.1.6.4 [dcl.spec.auto]/8 If the init-declarator-list contains more than one init-declarator, they shall all form declarations of variables. Why only by coincidence? The error message is a clue. Changing the functions to deduce the same return type causes … 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
decltype gives the declared type of the expression that is passed to it. auto does the same thing as template type deduction. So, for example, if you have a function that returns a reference, auto will still be a value (you need auto& to get a reference), but decltype will be exactly the type of … Read more
auto was a keyword that C++ “inherited” from C that had been there nearly forever, but virtually never used because there were only two possible conditions: either it wasn’t allowed, or else it was assumed by default. The use of auto to mean a deduced type was new with C++11. At the same time, auto … 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 forwarding reference, auto&& or T&&, will bind to anything. … Read more
auto can aid performance by avoiding silent implicit conversions. An example I find compelling is the following. std::map<Key, Val> m; // … for (std::pair<Key, Val> const& item : m) { // do stuff } See the bug? Here we are, thinking we’re elegantly taking every item in the map by const reference and using the … Read more