C++17 class template partial deduction

Question

My understanding about the Template argument deduction for class templates proposal was to homogenize the behaviour of template functions and template classes in deduction contexts. But I think that I have misunderstood something.

If we have this template object:

template <std::size_t S, typename T>
struct test
{
    static constexpr auto size = S;
    using type_t = T;

    test(type_t (&input)[size]) : data(input) {}
    type_t (&data)[size]{};
};

I tend to use a helper function as syntactic sugar for creating test objects:

template <std::size_t S, typename T>
test<S, T> helper(T (&input)[S]) { return input; }

Which can be used as shown below:

int main()
{
    int buffer[5];

    auto a = helper<5, int>(buffer); // No deduction
    auto b = helper<5>(buffer);      // Type deduced
    auto c = helper(buffer);         // Type and size deduced

    std::cout << a.size << b.size << c.size;

    return 0;
}

The code above outputs 555 as expected. I've tried the same in Wandbox using the newer compiler setup¹:

int main()
{
    int buffer[5];

    test<5, int> a(buffer); // No deduction: Ok.
    test<5> b(buffer);      // Type deduced: FAILS.
    test c(buffer);         // Type and size deduced: Ok.

    std::cout << a.size << b.size << c.size;

    return 0;
}

It looks like template argument deduction for class templates works only deducing all the parameters, I was expecting both behaviours (helper function and class template) to be the same, did I misunderstood something?

¹The last compilers availables in Wandbox are gcc HEAD 7.0.1 201701 and clang HEAD 5.0.0 (trunk).

Is type_t (&data)[size]{}; an array reference? Is the {} an initializer? Does that compile? Also, sintactic sugar sounds pretty naughty. :) — wally
Note that adding an explicit deduction guide does not help. I believe that partial deduction is not supported as the standard defines a deduction placeholders in terms of a template name (i.e. with no <...> syntax). Therefore test<5> is not a valid deduction placeholder. — Vittorio Romeo
@Muscampester type_t (&data)[size]{}; is an array reference, yes. The {} is indeed the initializer, and it compiles try it out!. About sintactic sugar what can I say... :'( english is not my mother tonghe and I do lots of mistakes! — PaperBirdMaster
From what I remember, it was deemed undesirable to have something like tuple<int> t{5, nullptr}; be accepted. — chris

metalfox metalfox · Accepted Answer · 2017-01-25T15:02:21

From this excellent trip report by Botond Ballo:

The feature as originally proposed included a provision for partial deduction, where you explicitly specify some of the template arguments, and leave the rest to be deduced, but this was pulled over concerns that it can be very confusing in some cases:
// Would have deduced tuple<int, string, float>,
// but tuple<int> is a well-formed type in and of itself!
tuple<int> t(42, "waldo", 2.0f);

C++17 class template partial deduction

2 Answers