J'ai le code suivant:

template <typename TC>
class C
{
    struct S
    {
        template <typename TS>
        void fun() const
        {}
    };

    void f(const S& s)
    {
        s.fun<int>();
    }
};

// Dummy main function
int main()
{
    return 0;
}

Lors de la construction de ceci avec gcc 9.2 et clang (9.0), j'obtiens une erreur de compilation en raison du templatemot clé requis pour l'invocation fun. Clang montre:

error: use 'template' keyword to treat 'fun' as a dependent template name
        s.fun<int>();
          ^
          template 

Je ne comprends pas pourquoi le compilateur pense que func'est un nom dépendant dans le contexte de f, car ce fn'est pas un modèle lui-même. Si je change Cpour être une classe régulière au lieu d'un modèle, l'erreur disparaît; cependant, je ne vois pas pourquoi il devrait y avoir une erreur en premier lieu puisque ni Sni fdépendre TC.

Curieusement, MSVC 19.22 compile cela très bien.

Remarque

Avant de voter pour fermer en tant que dupe de Où et pourquoi dois-je mettre les mots-clés "modèle" et "nom de type"? veuillez considérer qu'il s'agit d'un cas spécial où même s'il Ss'agit bien d'un nom dépendant, dans le contexte de fcelui-ci ne serait pas dépendant sinon du fait qu'ils sont membres de l'instanciation actuelle.

Considérez :

template<typename T>
struct C
{
    struct S
    {
        int a = 99;
    };

    void f(S s, int i)
    {
        s.a<0>(i);
    }
};

template<>
struct C<long>::S
{
    template<int>
    void a(int)
    {}
};

int main()
{
    C<int>{}.f({}, 0); // #1
    C<long>{}.f({}, 0); // #2
}

s.a<0>(i)est analysé comme une expression contenant deux opérations de comparaison <et >, et cela convient pour # 1 mais échoue pour # 2.

Si cela est changé en s.template a<0>(i)alors # 2 est OK et # 1 échoue. Ainsi, le templatemot clé n'est jamais redondant ici.

MSVC est capable d'interpréter l'expression dans les s.a<0>(i)deux sens au sein du même programme. Mais ce n'est pas correct selon la norme; chaque expression ne doit avoir qu'une seule analyse pour le compilateur.

funpeut ou peut ne pas être une fonction de modèle (ou peut ne pas exister du tout) selon le paramètre de modèle de class C.

C'est parce que vous pouvez vous spécialiser S(sans vous spécialiser C):

template <> struct C<int>::S {};

Parce que le compilateur veut savoir s'il funs'agit d'un modèle ou non lors de la première consultation class C(avant de remplacer le paramètre de modèle), templateest requis.