如何解决这种歧义？

Question

In the following code:

template <int...> struct IndexSequence {};

template <int, int, typename, int...> struct Helper;

template <int Start, typename Coefficients, int... Is>
struct Helper<Start, Start, Coefficients, Is...> {
    using type = IndexSequence<Is...>;
};

template <int Start, int N, int... As, int... Is>
struct Helper<Start, N, IndexSequence<As...>, Is...> :
    Helper<Start, N-1, IndexSequence<As...>, N-1, Is...> {};

int main() {
    Helper<2,5, IndexSequence<1,2,3>>::type a;
}

I get the compile error:

ambiguous class template instantiation for 'struct Helper<2, 2, IndexSequence<1, 2, 3>, 2, 3, 4>'

I figured it would resolve to the specialization

template <int Start, typename Coefficients, int... Is>
struct Helper<Start, Start, Coefficients, Is...> {
    using type = IndexSequence<Is...>;
};

But I guess it is also reading

struct Helper<Start, N, IndexSequence<As...>, Is...> :
    Helper<Start, N-1, IndexSequence<As...>, N-1, Is...> {};

So how to resolve this ambiguity?

Answer 1

The problem is essentially that none of the specializations is more specialized than the other.

When deciding which partial specialization too choose, the specializations are first matched against the arguments to check whether they are viable (here, both are). If multiple are viable, then to decide which one is to be chosen we have to check which one is more specialized than all others. This process is called "partial ordering" and done by comparing the specialized template "arguments" which each other (ie the template arguments in Helper<...> ) - one template is taken as the argument template, and the other is the parameter template. The argument template provides the types, and deduction is performed to see if the template parameters from the parameter template can be deduced given the argument template's types.

template <int Start, typename Coefficients, int... Is>
struct Helper<Start, Start, Coefficients, Is...>
//            ^^^^^  ^^^^^  ^^^^^^^^^^^^  ^^^^^
//   A:         1      2         3          4

template <int Start, int N, int... As, int... Is>
struct Helper<Start, N, IndexSequence<As...>, Is...>
//            ^^^^^  ^  ^^^^^^^^^^^^^^^^^^^^  ^^^^^
//   B:         1    2            3             4

For each argument of the argument template, some unique value is made up for each template parameter and substituted into the argument. These transformed arguments are then passed to the parameter template to check whether deduction succeeds or fails. As an example:

• A1 is deduced against B1, which succeeds. ( int can be deduced from int )
• B1 is deduced against A1, ... as above. Works fine.

Let's now look at the crucial deductions:

• B2 is deduced against A2, but as we used unique values for both Start and N , Start in template A is deduced inconsistently , which means that deduction fails here.

• A3 is deduced against B3, but since Coefficients is some unique type (not a specialization of IndexSequence !), deduction fails again.

Deduction failed at least once in both directions: Thus no template is in its entirety more specialized than the other.

---

Solve this partial ordering ambiguity by eg writing the first specialization as

template <int Start, int... As, int... Is>
struct Helper<Start, Start, IndexSequence<As...>, Is...> {
    using type = IndexSequence<Is...>;
};

Now, the second deduction that failed above doesn't fail anymore. Only the one that took specialization B as the argument template. That means that B is more specialized, and thus selected.

Demo .