Trailing return type

Uses your system voice; voice and rate in settings.

Snapshot

≈ 3 min read

Names in other languages

No names in other languages are held for this entry yet.

Article bodies are English and are not machine-translated. A name in another language is not a translation of the article.

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.

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 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 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 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 auto add(const L& lhs, const R& rhs) -> decltype(lhs + rhs) { return lhs + rhs; }

See also

Language enhancements of C++ 11

References

Text derived from https://en.wikipedia.org/w/index.php?oldid=1371665598 under CC BY-SA 4.0; modifications have been made.

Provenance

snapshot enwiki-001371665598 · captured 1787850358.0 · version history

Cite this page as: encyclopegia.org, “Trailing return type”, snapshot enwiki-001371665598. https://encyclopegia.org/a/trailing-return-type

Sources cited in this revision

3 named source(s) extracted from the cited revision. A source with no author is shown by its publication; nothing is invented.