Parameter pack with default template argument

Question

In this code, I'm trying to generalize Test from using Arg to using Args.... The problem is the default template argument. What I have below compiles, except when I uncomment the commented-out line in main():

#include <iostream>
#include <type_traits>

struct A {
    void foo(int) const {}
    void foo(int, bool, char) const {}
};

template <typename...> struct voider { using type = void; };

template <typename... Ts>
using void_t = typename voider<Ts...>::type;

template <typename T, typename Arg, typename = void_t<T>>
struct Test : std::false_type {};

template <typename T, typename Arg>
struct Test<T, Arg, void_t<decltype(std::declval<T&>().foo(std::declval<Arg>()))>> :
    std::true_type {};

// Trying to generalize Test with Args... instead of Arg
template <typename T, typename, typename... Args> struct Check;

template <typename T, typename... Args>
struct Check<T, void_t<T>, Args...> : std::false_type {};

template <typename T, typename... Args>
struct Check<T, void_t<decltype(std::declval<T&>().foo(std::declval<Args>()...))>, Args...>
    : std::true_type {};

template <typename T, typename... Args>
using CheckArgs = Check<T, void_t<T>, Args...>;

int main() {
    std::cout << std::boolalpha << Test<A, int>::value << '\n';  // true
//  std::cout << CheckArgs<A, int, bool, char>::value << '\n';  // ambiguous
}

The last line in main() is ambiguous. Firstly, why is it ambiguous, while the first line in main() is not? And secondly, how to fix the code so that the last line in main will compile (it is supposed to evaluate to true since int, bool, char are arguments of A::foo)?

I didn't expect that. But the first line should definitely evaluate to true (that's what GCC 5.1.0 gives). — prestokeys, Sep 16 '15 at 23:28
I haven't really researched why yet, but the fact this compiles here (second line too) means the compilers are quite different. That's to be expected. Both return false at the moment. — JVene, Sep 16 '15 at 23:49
Ok, first one down... in the code you posted, change std::false_type to std::true_type in the declaration of Test, then the first line DOES return true; — JVene, Sep 17 '15 at 00:02
But we must use std::false_type there, because that default specialization is reached only if `decltype(std::declval().foo(std::declval())` cannot be evaluated, i.e. `A::foo` does that not have that particular `Arg` as argument (which means `Test::value` must evaluate to false). I really do think VS2015 is bugged in its output here. But as for compiling/not compiling the second line, I don't know if it is GCC or VS2015 that is buggy. — prestokeys, Sep 17 '15 at 00:07
Your Test struct returns true even if the signature does not match on my system. Change Test::value to Test ::value and check it out for yourself. — bku_drytt, Sep 17 '15 at 01:04
@bku_drytt Because char is convertible to int (but yeah, that should be avoided too, which is a separate problem). Use `Test::value`, and it will evaluate to false. — prestokeys, Sep 17 '15 at 01:16
I had a different bug while trying to implement the exact same functionality and arrived to this question :) — CygnusX1, Jul 05 '19 at 22:22

score 7 · Accepted Answer · answered Sep 17 '15 at 05:04

You want

template <typename T, typename, typename... Args> 
struct Check : std::false_type {};

template <typename T, typename... Args>
struct Check<T, void_t<decltype(std::declval<T&>().foo(std::declval<Args>()...))>, Args...>
    : std::true_type {};

You want the primary template to provide the default case - which is false, and the partial specialization to supply the true case. When you write two partial specializations, both are viable, and there's no ordering between the two, so it ends up being ambiguous

And this is just reimplementing a more constrained version of std::experimental::is_detected.

Parameter pack with default template argument

1 Answers1