Advantages of Trailing Return Types

Trailing return types, while particularly beneficial in template functions, offer several other advantages that can enhance code readability and maintainability:

Improved Readability for Complex Return Types

For functions returning complex types, placing the return type after the parameter list can make the function signature clearer and easier to read. This is especially helpful when the return type involves templates or other intricate constructs. For example:

1#include <iostream>
2#include <memory>
3
4template<typename T1, typename T2>
5class MyClass {
6 public:
7  MyClass(T1 param1, T2 param2)
8    : param1_(param1), param2_(param2) {}
9  void Display() const {
10    std::cout
11      << "MyClass: param1 = " << param1_
12      << ", param2 = " << param2_ << std::endl;
13  }
14
15 private:
16  T1 param1_;
17  T2 param2_;
18};
19
20auto CreateComplexObject(int param1, double param2)
21  -> std::unique_ptr<MyClass<int, double>> {
22  return std::make_unique<
23    MyClass<int, double>>(param1, param2);
24}
25
26int main() {
27  auto obj = CreateComplexObject(42, 3.14);
28  obj->Display();
29}

1MyClass: param1 = 42, param2 = 3.14

Enhanced Consistency

Using trailing return types uniformly across a codebase can lead to more consistent and readable code. By always placing the return type after the function name and parameters, developers can maintain a predictable structure in their function declarations.

Emphasis on Function Name

Traditional function syntax places the return type before the function name, which can sometimes detract from quickly identifying what the function does. Trailing return types allow the function name to appear first, emphasizing the action performed by the function rather than its return type.

Alignment of Function Names

In classes with many member functions, trailing return types can help align the function names vertically. This alignment can make it easier to scan through a list of functions and quickly understand the class's interface.

1#include <iostream>
2#include <string>
3
4class MyClass {
5public:
6auto GetValue() const -> int {
7  return value_; }
8
9auto SetValue(int newValue) -> void {
10  value_ = newValue; }
11
12auto GetName() const -> std::string {
13  return name_; }
14
15auto SetName(std::string newName) -> void {
16  name_ = std::move(newName); }
17
18private:
19int value_ = 0;
20std::string name_ = "Default";
21}
22;
23
24int main() {
25  MyClass obj;
26  std::cout << "Initial Value: "
27    << obj.GetValue() << std::endl;
28  std::cout << "Initial Name: "
29    << obj.GetName() << std::endl;
30
31  obj.SetValue(100);
32  obj.SetName("UpdatedName");
33
34  std::cout << "Updated Value: "
35    << obj.GetValue() << std::endl;
36  std::cout << "Updated Name: "
37    << obj.GetName() << std::endl;
38}

1Initial Value: 0
2Initial Name: Default
3Updated Value: 100
4Updated Name: UpdatedName

While the use of trailing return types outside of template functions often comes down to personal preference and coding style, these benefits highlight their potential to improve the clarity and consistency of your code.

Some developers and codebases may prefer traditional return type syntax for its familiarity and simplicity, but trailing return types offer a viable alternative for those looking to enhance readability.