> ## Documentation Index > Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt > Use this file to discover all available pages before exploring further. # C++ Trailing Return Type A trailing return type is a C++11 function declaration syntax where the return type is specified after the function's parameter list, rather than preceding the function name. It utilizes the `auto` keyword as a leading syntactic placeholder and the `->` operator to denote the actual return type. ## Syntax ```cpp theme={"dark"} // Traditional declaration return_type function_name(parameter_list); // Trailing return type declaration auto function_name(parameter_list) -> return_type; ``` ## Technical Mechanics **The `auto` Placeholder** When used with a trailing return type, the leading `auto` keyword acts strictly as a parser directive. It indicates to the compiler that the return type is not missing, but rather deferred to the end of the signature. **Lexical Scoping and Name Lookup** In a traditional function declaration, the return type undergoes name lookup before the compiler parses the parameter list. Consequently, the parameter names are not yet in scope during the name lookup phase of a leading return type. In a trailing return type declaration, name resolution for the return type occurs *after* the parameter list. Therefore, the function's parameters are in scope and visible to expressions within the return type. ```cpp theme={"dark"} // 'a' and 'b' are in scope for name lookup within decltype auto add(int a, double b) -> decltype(a + b) { return a + b; } ``` Furthermore, trailing return types alter class scope injection for out-of-line member function definitions. Because the trailing return type is parsed after the function name and its class qualifier (e.g., `MyClass::`), name lookup for the trailing return type occurs within the scope of the class. This permits the use of nested types, enumerations, or aliases defined within the class without requiring redundant class name qualifiers. ```cpp theme={"dark"} class MyClass { public: struct NestedType { int data; }; NestedType process(); }; // Traditional: Requires MyClass:: qualifier on the return type MyClass::NestedType MyClass::process() { return {1}; } // Trailing: Class scope is injected after MyClass::, so NestedType is directly visible auto MyClass::process() -> NestedType { return {1}; } ``` **Lambda Expressions** Trailing return types are the exclusive syntax allowed for explicitly specifying the return type of a lambda expression. Traditional leading return types cannot be parsed in lambda declarations. ```cpp theme={"dark"} // Explicitly specifying 'double' as the return type for a lambda auto divide = [](int a, int b) -> double { return static_cast(a) / b; }; ``` **CV-Qualifiers and Reference Modifiers** When applying `const`, `volatile`, or reference modifiers (`&`, `&&`) to member functions, the trailing return type follows the parameter list but precedes the function body. The cv-qualifiers and reference qualifiers for the implicit `this` pointer must be placed *before* the `->` operator. ```cpp theme={"dark"} class Example { public: // 'const' modifies the member function, placed before the trailing return type auto get_value() const -> int { return value; } private: int value; }; ``` **Complex Type Declarations** Trailing return types isolate the return type as a distinct `type-id` at the end of the declaration, separating it from the function identifier. While this visually simplifies signatures for functions returning pointers to arrays or pointers to functions, the trailing `type-id` itself still adheres to standard C++ parsing rules and precedence. The `type-id` follows standard inside-out reading rules; for example, the parentheses around the pointer `*` in `int(*)[10]` remain mandatory to prevent the compiler from parsing it as an array of pointers. ```cpp theme={"dark"} // Traditional: Returns a pointer to an array of 10 integers int (*get_array_ptr())[10]; // Trailing: Isolates the type-id, but standard precedence still applies to int(*)[10] auto get_array_ptr() -> int(*)[10]; // Traditional: Returns a pointer to a function taking an int and returning a double double (*get_func_ptr())(int); // Trailing: Isolates the type-id, but standard precedence still applies to double(*)(int) auto get_func_ptr() -> double(*)(int); ``` ## Interaction with C++14 Return Type Deduction In C++14 and later, the `->` operator and the trailing type can be omitted entirely, allowing the compiler to deduce the return type from the `return` statement(s) in the function body. If the `->` operator is present, the compiler enforces the specified trailing type. However, the trailing return type itself can be `auto` or `decltype(auto)`. In these cases, the compiler still performs return type deduction despite the presence of the `->` operator. ```cpp theme={"dark"} auto func_deduced() { return 5; } // C++14: Deduces 'int' auto func_trailing() -> double { return 5; } // C++11: Explicitly 'double', no deduction auto func_trailing_deduced() -> decltype(auto) { return 5; } // C++14: Deduction occurs via trailing type ```

Tired of Poor C++ Skills? Fix That With Deep Grasping! Learn More