appel Ambigu lorsque vous appelez la fonction récursive modèle variadique surcharge

Question

Considérez ce morceau de code:

template<typename FirstArg> 
void foo() 
{ 
} 

template<typename FirstArg, typename... RestOfArgs> 
void foo() 
{ 
    foo<RestOfArgs...>(); 
} 

int main() 
{ 
    foo<int, int, int>(); 
    return 0; 
} 

Il ne compile pas en raison de l'appel foo<RestOfArgs...>(); ambigu quand RestOfArgs n'a qu'un seul élément ({int}).

Mais cette compile sans erreur:

template<typename FirstArg> 
void foo(FirstArg x) 
{ 
} 

template<typename FirstArg, typename... RestOfArgs> 
void foo(FirstArg x, RestOfArgs... y) 
{ 
    foo(y...); 
} 

int main() 
{ 
    foo<int, int, int>(5, 6, 7); 
    return 0; 
} 

Pourquoi est-il une ambiguïté dans le premier cas?

Pourquoi n'y a-t-il pas d'ambiguïté dans le second cas?

Answer 1

Pourquoi y a-t-il ambiguïté dans le premier cas?

RestOfArgs peut être vide.

Alors foo<int> peut être instancié comme:

template<int> 
void foo() 
{ 
} 

et

template<int,> 
void foo() 
{ 
    foo<>(); 
} 

les deux seront compilés, il est ambigu.

En fait foo<>() ne compilera pas, mais il échoue dans l'instanciation suivante, donc cela n'a pas d'importance.

Pourquoi n'y a-t-il pas d'ambiguïté dans le second cas?

foo<int>(7) peut être instancié comme:

template<int> 
void foo(int 7) 
{ 
} 

et

template<int> 
void foo(int 7) 
{ 
    foo(); 
} 

mais le second est une erreur, car il n'y a pas foo prendre aucun argument, donc le seul candidat est le premier un, donc il n'y aura pas d'ambiguïté

Answer 2

The answer by @ZangMingJie répond à la différence de comportement que vous observez dans votre code.

je l'ai trouvé plus facile de comprendre la résolution de nom avec la modification suivante:

template<typename FirstArg> 
void foo() 
{ 
    printf("1\n"); 
} 

template<typename FirstArg, typename SecondArg, typename... RestOfArgs> 
void foo() 
{ 
    printf("2\n"); 
    foo<SecondArg, RestOfArgs...>(); 
} 

int main() 
{ 
    foo<int, int, int>(); 
    return 0; 
} 

Quand il y a des paramètres sont utilisés deux modèles ou plus, la seconde fonction s'invoquée. Quand il y a un paramètre de template, la première fonction est invoquée.

Answer 3

Dans Function template overloading

Il y a beaucoup de règles à dire qui fonctionne modèle est plus spécialisé (selon les paramètres donnés).

Le point qui fait

template<typename> void foo(); 
template<typename, typename...> void foo(); 

ambiguë pour foo<int>(), mais pas

template<typename T> void foo(T); 
template<typename T, typename... Ts> void foo(T, Ts...); 

pour foo(42) est le suivant:

In case of a tie, if one function template has a trailing parameter pack and the other does not, the one with the omitted parameter is considered to be more specialized than the one with the empty parameter pack.