Ho il codice seguente:

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;
}

Quando lo costruisco con gcc 9.2 e clang (9.0), ricevo un errore di compilazione a causa della templateparola chiave richiesta per invocare fun. Clang mostra:

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

Non capisco perché il compilatore pensi funsia un nome dipendente nel contesto di f, dal momento che fnon è un modello stesso. Se cambio Cad essere una classe normale anziché un modello, l'errore scompare; tuttavia, non vedo perché ci dovrebbe essere un errore in primo luogo poiché né Sné fdipende TC.

Stranamente, MSVC 19.22 lo compila bene.

Nota

Prima di votare per chiudere come duplicato di Dove e perché devo inserire le parole chiave "template" e "typename"? si prega di considerare che questo è un caso speciale in cui anche se Sè effettivamente un nome dipendente, nel contesto di fesso non sarebbe dipendente se non per il fatto che sono membri della presente istanza.

Considera :

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)viene analizzato come un'espressione contenente due operazioni di confronto <e >, e questo va bene per il n. 1 ma fallisce per il n. 2.

Se questo viene modificato in s.template a<0>(i)# 2 è OK e # 1 non riesce. Pertanto la templateparola chiave non è mai ridondante qui.

MSVC è in grado di interpretare l'espressione in s.a<0>(i)entrambi i modi all'interno dello stesso programma. Ma questo non è corretto secondo lo standard; ogni espressione dovrebbe avere una sola analisi da gestire per il compilatore.

funpuò o meno essere una funzione modello (o potrebbe non esistere affatto) a seconda del parametro modello di class C.

Questo perché puoi specializzarti S(senza specializzarti C):

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

Perché il compilatore vuole sapere se funè un modello o meno al primo sguardo class C(prima di sostituire il parametro template), templateè necessario.