What is “->” after function declaration?

by

It’s the new function declaration syntax from C++11, and it’s called the “trailing return type”. At the end of a function declaration, -> means that the following is the return type of the function. It can only be used when the auto keyword is used instead of an actual return type where you would normally expect it.

For instance, these two declarations are compatible:

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

Depending on your tastes, you may find it prettier than the old declaration syntax, especially when the return type is extremely long/complex:

task<typename details::_TaskTypeFromParam<_Ty>::_Type> create_task(_Ty _Param);
auto create_task(_Ty _Param) -> task<typename details::_TaskTypeFromParam<_Ty>::_Type>;

But sometimes it can be necessary with templates, when the return type of the function could vary with the arguments.

Say you want a templated function to add variables:

template<typename T>
T add(const T& x, const T& y)
{
    return x + y;
}

That’s great, but you’ll only be able to add variables of the same type. Suppose you would like to be able to add variables of any type (like add((int)1, (double)2)).

template<typename T, typename U>
??? add(const T& x, const U& y)
{
    return x + y;
}

EDIT: note that in C++14 and onwards, it’s legal to write auto add(const T& x, const U& y), without a trailing return type, for function definitions (in other words, when you define the body of your function).

The problem is that you can’t tell in advance what the result type of x + y will be. As templates stand, they could even be non-integral types. (Wouldn’t you like to be able to do add(std::string("x"), "y")?)

Decltype, along with the new function declaration syntax, lets you solve this problem.

template<typename T, typename U>
auto add(const T& x, const U& y) -> decltype(x + y)
{
    return x + y;
}

Decltype “returns” the type of an expression. Since you need x and y to have been declared for decltype(x + y) to work, you need the new syntax.

More Related Contents:

  1. Is it possible to figure out the parameter type and return type of a lambda?
  2. Will two atomic writes to different locations in different threads always be seen in the same order by other threads?
  3. Can’t pass temporary object as reference
  4. Is the size of std::array defined by standard
  5. constexpr and initialization of a static const void pointer with reinterpret cast, which compiler is right?
  6. Delegate Constructor C++
  7. Selecting a member function using different enable_if conditions
  8. std::map emplace without copying value
  9. When to use std::begin and std::end instead of container specific versions [duplicate]
  10. How does the range-based for work for plain arrays?
  11. In C++11, does `i += ++i + 1` exhibit undefined behavior?
  12. What exactly is an R-Value in C++?
  13. Garbage Collection in C++ — why?
  14. std::unique_ptr, deleters and the Win32 API
  15. C++ Modules – why were they removed from C++0x? Will they be back later on?
  16. Which headers in the C++ standard library are guaranteed to include another header?
  17. Default template argument when using std::enable_if as templ. param.: why OK with two template functions that differ only in the enable_if parameter?
  18. How can an incomplete type be used as a template parameter to vector here?
  19. How can I use C++ 11 features in Clang?
  20. When Does Move Constructor get called?
  21. Questions about Hinnant’s stack allocator
  22. Equivalent of “using namespace X” for scoped enumerations?
  23. The implementation of random_device in VS2010?
  24. I want to kill a std::thread using its thread object? [duplicate]
  25. What expressions create xvalues?
  26. Why does the template-id in “A=0” not compile without space because of the greater-or-equal-than operator “>=”?
  27. Overloading on R-value references and code duplication
  28. Unable to print the value of nullptr on screen
  29. template parameter packs access Nth type and Nth element
  30. Can the ‘type’ of a lambda expression be expressed?

Leave a Comment