Using a hyperlinked C++ grammar, the parsing of decltype(void()) is: decltype( expression ) decltype( assignment-expression ) decltype( conditional-expression ) … lots of steps involving order of operations go here … decltype( postfix-expression ) decltype( simple-type-specifier ( expression-listopt ) ) decltype( void() ) So void() is a kind of expression here, in particular a postfix-expression. Specifically, … Read more
result_of was introduced in Boost, and then included in TR1, and finally in C++0x. Therefore result_of has an advantage that is backward-compatible (with a suitable library). decltype is an entirely new thing in C++0x, does not restrict only to return type of a function, and is a language feature. Anyway, on gcc 4.5, result_of is … Read more
Is it valid? Your last example is well-formed, while the first one is not (so GCC is correct). Paragraph 3.4.1/7 on unqualified name lookup specifies: A name used in the definition of a class X outside of a member function body, default argument, brace-or- equal-initializer of a non-static data member, or nested class definition shall … Read more
c is the name of a variable; (c) is an expression, in this case an lvalue expression, whose value is identical to the value of the variable c. And the two are treated differently by decltype. Consider, for example, decltype(1+2), which is also an example taking an expression. It just so happens that your example … Read more
It’s an comma-separated list of expressions, the type is identical to the type of the last expression in the list. It’s usually used to verify that the first expression is valid (compilable, think SFINAE), the second is used to specify that decltype should return in case the first expression is valid.
I think the problem is that the variadic function template is only considered declared after you specified its return type so that sum in decltype can never refer to the variadic function template itself. But I’m not sure whether this is a GCC bug or C++0x simply doesn’t allow this. My guess is that C++0x … Read more
In C++11, there are two syntaxes for function declaration: return-type identifier ( argument-declarations… ) and auto identifier ( argument-declarations… ) -> return_type They are equivalent. Now when they are equivalent, why do you ever want to use the latter? Well, C++11 introduced this cool decltype thing that lets you describe type of an expression. So … Read more
Just above that example, it says if e is an unparenthesized id-expression or a class member access (5.2.5), decltype(e) is the type of the entity named by e. if e is an lvalue, decltype(e) is T&, where T is the type of e; I think decltype(a->x) is an example of the “class member access” and … Read more
It is not easy to understand these concepts without getting formal. The primer probably does not want to confuse you and avoids introducing terms such as “lvalue“, “rvalue“, and “xvalue“. Unfortunately, these are fundamental in order to understand how decltype works. First of all, the type of an evaluated expression is never a reference type, … 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