Arrow operator (->) in function heading

by

In C++11, there are two syntaxes for function declaration:

    return-type identifier ( argument-declarations… )

and

    auto identifier ( argument-declarations… ) -> return_type

They are equivalent. Now when they are equivalent, why do you ever want to use the latter? Well, C++11 introduced this cool decltype thing that lets you describe type of an expression. So you might want to derive the return type from the argument types. So you try:

template <typename T1, typename T2>
decltype(a + b) compose(T1 a, T2 b);

and the compiler will tell you that it does not know what a and b are in the decltype argument. That is because they are only declared by the argument list.

You could easily work around the problem by using declval and the template parameters that are already declared. Like:

template <typename T1, typename T2>
decltype(std::declval<T1>() + std::declval<T2>())
compose(T1 a, T2 b);

except it’s getting really verbose now. So the alternate declaration syntax was proposed and implemented and now you can write

template <typename T1, typename T2>
auto compose(T1 a, T2 b) -> decltype(a + b);

and it’s less verbose and the scoping rules didn’t need to change.

C++14 update: C++14 also permits just

    auto identifier ( argument-declarations… )

as long as the function is fully defined before use and all return statements deduce to the same type. The -> syntax remains useful for public functions (declared in the header) if you want to hide the body in the source file. Somewhat obviously that can’t be done with templates, but there are some concrete types (usually derived via template metaprogramming) that are hard to write otherwise.

More Related Contents:

  1. Why can I use auto on a private type?
  2. How much is too much with C++11 auto keyword?
  3. What are some uses of decltype(auto)?
  4. What is the type of lambda when deduced with “auto” in C++11?
  5. Should the trailing return type syntax style become the default for new C++11 programs? [closed]
  6. What does auto&& tell us?
  7. decltype and parentheses
  8. trailing return type using decltype with a variadic template function
  9. Why does auto x{3} deduce an initializer_list?
  10. Range-for-loops and std::vector
  11. C++ auto keyword. Why is it magic?
  12. C++11 auto: what if it gets a constant reference?
  13. Can the use of C++11’s ‘auto’ improve performance?
  14. What is decltype with two arguments?
  15. Significance of parentheses in decltype((c))?
  16. decltype as a return type in class member function
  17. Difference between std::result_of and decltype
  18. C++11 – declaring non-static data members as ‘auto’
  19. What does the void() in decltype(void()) mean exactly?
  20. What expressions yield a reference type when decltype is applied to them?
  21. The new keyword “auto”; When should it be used to declare a variable type? [duplicate]
  22. Advantage of using trailing return type in C++11 functions
  23. Why doesn’t the C++11 ‘auto’ keyword work for static members?
  24. C++11 Change `auto` Lambda to a different Lambda?
  25. Detect operator support with decltype/SFINAE
  26. Does ‘auto’ type assignments of a pointer in c++11 require ‘*’?
  27. How to use std::async on a member function?
  28. Which greedy initializer-list examples are lurking in the Standard Library?
  29. Undefined reference to process(std::__cxx11::basic_string … ) when compiling affdex linux sample applications
  30. C++ view types: pass by const& or by value?

Leave a Comment