appel ambigu d'un modèle surchargé avec le paramètre (const T&, const T&) ou (const char (&)[N], const char (&)[M])

Question

Pour le code suivant :

#include <iostream>
using std::cout; using std::endl;

template <typename T>
int compare(const T&, const T&) {
    cout << __PRETTY_FUNCTION__ << endl;
    return 0;
}
template <size_t N, size_t M>
int compare(const char (&)[N], const char (&)[M]) {
    cout << __PRETTY_FUNCTION__ << endl;
    return 0;
}

int main(int argc, char *argv[]) {
    compare("hi", "is");
}

Lorsque je compile le code avec g++ -std=c++1y Il se plaint :

error: call of overloaded ‘compare(const char [3], const char [3])’ is ambiguous
     compare("hi", "is");

Selon les règles de surcharge des templates, les fonctions viables sont :

compare(const T&, const T&) with T = char [3]
compare(const char (&)[N], const char (&)[M]) with N = 3ul, M = 3ul

Ils fournissent tous deux une correspondance aussi bonne (c'est-à-dire exacte) à l'appel. Je devrais donc vérifier laquelle est la plus spécialisée.

Mais d'après mes connaissances limitées, const T& est plus général que const char (&)[N] . Je pense donc que compare(const char (&)[N], const char (&)[M]) est plus spécialisé. Mais pourquoi cette appellation est-elle ambiguë ?

Answer 1

La première surcharge compare(const T&, const T&) oblige les deux paramètres à être du même type, alors que la seconde surcharge ne le fait pas. Donc, à cet égard, la première surcharge est plus spécifique.

Cependant, la deuxième surcharge oblige les deux paramètres à être char Il est donc plus spécifique à cet égard.

Par conséquent, on ne peut pas dire qu'une surcharge soit plus spécialisée que l'autre, d'où l'erreur d'ambiguïté.

Une autre façon de voir les choses est que chaque surcharge peut accepter une entrée que l'autre n'accepte pas : Seule la première surcharge acceptera un appel où les deux arguments sont int& . Et seule la seconde surcharge acceptera un appel où les arguments sont char (&)[2] y char (&)[3] .

Si vous changez la deuxième surcharge en

template <size_t N> int compare(const char (&)[N], const char (&)[N])

cela corrigera l'erreur, car cette surcharge est maintenant strictement plus spécifique que la première.