Following on from last tidbit showing how the decltype operator essentially queries the type of an expression, the second part of this overview discusses how decltype can be syntactically combined with auto (itself the subject of the March 2010 tidbit). This combination can be used to specify trailing return types, also known informally as "late specified return types".

Leaving aside the technical jargon, a simple example from section 8.3.5 of the C++11 standard usefully introduces this month's topic. Let's consider a template function like:

  template <class T, class U>
    ???
    foo(T t, U u)
    {
      return t + u;
    }

The question is: what should replace the question marks?

The problem is that we are dealing with a template, thus we don't know at the outset the types of T and U. Even if they were restricted to be arithmetic builtin types, non-trivial rules in C++ relate the type of the sum to the types of T and U. In the past - in the GNU C++ runtime library too - programmers used to address these situations by way of rather ugly tricks involving __typeof__ which now, with decltype, could be rewritten as:

  template <class T, class U>
    decltype((*(T*)0) + (*(U*)0))
    foo(T t, U u)
    {
      return t + u;
    }

Of course the latter is guaranteed to work only for builtin arithmetic types, eg, '0' must make sense. In short: it's a hack. On the other hand, in C++11 you can use auto:

  template <class T, class U>
    auto
    foo(T t, U u) -> decltype(t + u)
    {
      return t + u;
    }

This is much better. It's generic and a construct fully supported by the language.

Finally, let's see a real-life example directly taken from the C++11 runtime library as implemented in GCC:

  template<typename _IteratorL, typename _IteratorR>
    inline auto
    operator-(const reverse_iterator<_IteratorL>& __x,
	      const reverse_iterator<_IteratorR>& __y)
    -> decltype(__y.base() - __x.base())
    { return __y.base() - __x.base(); }

By now it should appear be completely straightforward.

The availability of trailing return types in C++11 allowed fixing a real bug in the C++98 implementation of this operator (and many similar ones). In GCC, C++98 mode, this operator is:

  template<typename _IteratorL, typename _IteratorR>
    inline typename reverse_iterator<_IteratorL>::difference_type
    operator-(const reverse_iterator<_IteratorL>& __x,
	      const reverse_iterator<_IteratorR>& __y)
    { return __y.base() - __x.base(); }

This was guaranteed to work well with heterogeneous reverse_iterator types only if difference_type was the same for both types.