Best Practices for Trailing Return Types

Here are some practices to consider when deciding whether to use trailing return types.

Use them when they're necessary

Trailing return types are most useful in template functions where the return type depends on the template parameters. If you don't need them, it's often simpler to stick to traditional return type syntax.

Keep them readable

Just because you can use trailing return types doesn't mean you should use overly complex expressions. If the return type is getting too complicated, consider simplifying your function or using a type alias.

1// This is hard to read:
2auto ComputeValue(int x, int y)
3-> decltype((x * y) / (x + y)) {
4  return (x * y) / (x + y);
5}
6
7// This is better:
8using ResultType = decltype((x * y) / (x + y));
9auto ComputeValue(int x, int y) -> ResultType {
10  return (x * y) / (x + y);
11}

Be consistent

If you're working on a team or codebase, agree on a consistent style. Either use trailing return types everywhere, or only use them when necessary. Mixing styles can lead to confusion.

Remember the const position

If you're using trailing return types with const member functions, remember that the const goes before the return type, not after.

1// Wrong:
2auto GetValue() -> int const;
3
4// Right:
5auto GetValue() const -> int;

Use clear and descriptive names

This is a general principle, but it's especially important with trailing return types. Since the return type comes after the function name, the name should clearly indicate what the function does and what it returns.

1// Unclear:
2auto Func(int x, int y) -> int;
3
4// Better:
5auto ComputeAverage(int x, int y) -> double;