Should the trailing return type syntax style become the default for new C++11 programs? [closed]

by

There are certain cases where you must use a trailing return type. Most notably, a lambda return type, if specified, must be specified via a trailing return type. Also, if your return type utilizes a decltype that requires that the argument names are in scope, a trailing return type must be used (however, one can usually use declval<T> to work around this latter issue).

The trailing return type does have some other minor advantages. For example, consider a non-inline member function definition using the traditional function syntax:

struct my_awesome_type
{
    typedef std::vector<int> integer_sequence;

    integer_sequence get_integers() const;
}; 

my_awesome_type::integer_sequence my_awesome_type::get_integers() const
{
    // ...
}

Member typedefs are not in scope until after the name of the class appears before ::get_integers, so we have to repeat the class qualification twice. If we use a trailing return type, we don’t need to repeat the name of the type:

auto my_awesome_type::get_integers() const -> integer_sequence
{
    // ...
}

In this example, it’s not such a big deal, but if you have long class names or member functions of class templates that are not defined inline, then it can make a big difference in readability.

In his “Fresh Paint” session at C++Now 2012, Alisdair Meredith pointed out that if you use trailing return types consistently, the names of all of your functions line up neatly:

auto foo() -> int;
auto bar() -> really_long_typedef_name;

I’ve used trailing return types everywhere in CxxReflect, so if you’re looking for an example of how code looks using them consistently, you can take a look there (e.g, the type class).

More Related Contents:

  1. Advantage of using trailing return type in C++11 functions
  2. Why can I use auto on a private type?
  3. How much is too much with C++11 auto keyword?
  4. What is the type of lambda when deduced with “auto” in C++11?
  5. What does auto&& tell us?
  6. Arrow operator (->) in function heading
  7. Why does auto x{3} deduce an initializer_list?
  8. Range-for-loops and std::vector
  9. C++ auto keyword. Why is it magic?
  10. C++11 auto: what if it gets a constant reference?
  11. Can the use of C++11’s ‘auto’ improve performance?
  12. C++11 – declaring non-static data members as ‘auto’
  13. The new keyword “auto”; When should it be used to declare a variable type? [duplicate]
  14. Why doesn’t the C++11 ‘auto’ keyword work for static members?
  15. C++11 Change `auto` Lambda to a different Lambda?
  16. Does ‘auto’ type assignments of a pointer in c++11 require ‘*’?
  17. Why C++11 in-class initializer cannot use parentheses?
  18. C++11 does not deduce type when std::function or lambda functions are involved
  19. Sorting zipped (locked) containers in C++ using boost or the STL
  20. When should I really use noexcept?
  21. Pretty-print std::tuple
  22. What does “default” mean after a class’ function declaration?
  23. Creating an array initializer from a tuple or variadic template parameters
  24. Why is std::function not equality comparable?
  25. What does “ provide, and where is it documented?
  26. How to make a variadic macro for std::cout?
  27. Can someone please explain the “indices trick”?
  28. Where is shared_ptr?
  29. Is there a range class in C++11 for use with range based for loops?
  30. Understanding rvalue references

Leave a Comment