Is There a Shortcut to decltype

Question

In this answer I wrote the C++17 code:

cout << accumulate(cbegin(numbers), cend(numbers), decay_t<decltype(numbers[0])>{});

This received some negative commentary about the nature of C++'s type association, which I'm sad to say that I agree with :(

decay_t<decltype(numbers[0])>{} is a very complex way to get a:

Zero-initialized type of an element of numbers

Is it possible to maintain the association with the type of numbers' elements, but not type like 30 characters to get it?

EDIT:

I've got a lot of answers involving the a wrapper for either accumulate or for extracting the type from numbers[0]. The problem being they require the reader to navigate to a secondary location to read a solution that is no less complex than the initialization code decay_t<decltype(numbers[0])>{}.

The only reason that we have to do more than this: decltype(numbers[0]) Is because the array subscript operator returns a reference:

error: invalid cast of an rvalue expression of type 'int' to type 'int&'

It's interesting that with respect to decltype's argument:

If the name of an object is parenthesized, it is treated as an ordinary lvalue expression

However, decltype((numbers[0])) is still just a reference to an element of numbers. So in the end these answers may be as close as we can come to simplifying this initialization :(

Answer 1

While I would always choose to write a helper function as per @Barry, if numbers is a standard container, it will export the type value_type, so you can save a little complexity:

cout << accumulate(cbegin(numbers), cend(numbers), decltype(numbers)::value_type());

going further, we could define this template function:

template<class Container, class ElementType = typename Container::value_type>
constexpr auto element_of(const Container&, ElementType v = 0)
{
    return v;
}

which gives us this:

cout << accumulate(cbegin(numbers), cend(numbers), element_of(numbers, 0));

Answer 2

Personal preference: I find the decay_t, decltype and declval dance pretty annoying and hard to read.

Instead, I would use an extra level of indirection through a type-trait value_t<It> and zero-initialization through init = R{}

template<class It>
using value_t = typename std::iterator_traits<It>::value_type;

template<class It, class R = value_t<It>>
auto accumulate(It first, It last, R init = R{}) { /* as before */ }

Answer 3

I think the best you can do is just factor this out somewhere:

template <class It, class R = std::decay_t<decltype(*std::declval<It>())>>
R accumulate(It first, It last, R init = 0) {
    return std::accumulate(first, last, init);
}

std::cout << accumulate(cbegin(numbers), cend(numbers));

Or more generally:

template <class Range, class T =
        std::decay_t<decltype(*adl_begin(std::declval<Range&&>()))>>
T accumulate(Range&& range, T init = 0) {
    return std::accumulate(adl_begin(range), adl_end(range), init);
}

cout << accumulate(numbers);

where adl_begin is a version of begin() that accounts for ADL.

Sure, we technically still have all the cruft that you were trying to avoid earlier... but at least now you never have to look at it again?