In computer programming, a subroutine (a.k.a. function) will often inform calling code about the result of its computation, by returning a value to that calling code. The data type of that value is called the function's return type.
In the C++ programming language, a function must be declared. The C++ function's return type is specified as a part of declaring that function. A trailing return type, a syntax feature available since C++11, is like a traditional return type, except that it is specified in a different location.
Syntax An ordinary return type is specified before the function's name. In this example of traditional C++ code, the return type of hasMultipleItems() is bool: using std::vector;
class MyClass { private: vector<int> items; public: bool hasMultipleItems() { return items.size() > 1;
A trailing return type is specified after the parameter list, following -> symbols: using std::vector;
class MyClass { private: vector<int> items; public: auto hasMultipleItems() -> bool { return items.size() > 1;
Distinction from other language features In modern C++, the meaning of the auto keyword will depend on its context: When used in a variable's definition (e.g., auto x = 11;), the auto keyword indicates type inference. The data type for that x will be deduced from its initialization. Starting with C++14, the return type of a function can also be inferred by using auto without specifying a trailing return type. For example: auto hasMultipleItems() { return items.size() > 1; } On the other hand, there is no type inference in the hasMultipleItems() example on the previous section. That example only uses the auto keyword as a syntactic element, because a trailing return type is being used.
Rationale Consider the task of programming a generic version of the following: int add(const int& lhs, const int& rhs) { return lhs + rhs; } A proper expression of this function's return type would use the two formal parameter names with decltype: decltype(lhs + rhs). However, where a return type is traditionally specified, those two formal parameters are not yet in scope.
Consequently, this code will not compile: // This will not compile template <typename L, typename R> decltype(lhs + rhs) add(const L& lhs, const R& rhs) { return lhs + rhs; }
However, where a trailing return type is specified, the formal parameters are in scope: template <typename L, typename R> auto add(const L& lhs, const R& rhs) -> decltype(lhs + rhs) { return lhs + rhs; }
See also Language enhancements of C++ 11
References