Errore di modello confuso

Ho giocato con clang per un po 'e sono incappato in "test / SemaTemplate / dependance-template-recover.cpp" (nella distribuzione clang) che dovrebbe fornire suggerimenti per il ripristino da un errore di modello.

Il tutto può essere facilmente ridotto a un esempio minimo:

template<typename T, typename U, int N> struct X {
    void f(T* t)
    {
        // expected-error{{use 'template' keyword to treat 'f0' as a dependent template name}}
        t->f0<U>();
    }
};

Il messaggio di errore prodotto da clang:

tpl.cpp:6:13: error: use 'template' keyword to treat 'f0' as a dependent template name
         t->f0<U>();
            ^
            template 
1 error generated.

... Ma ho difficoltà a capire dove esattamente si dovrebbe inserire la templateparola chiave per avere il codice sintatticamente corretto?

ISO C ++ 03 14.2 / 4:

Quando il nome di una specializzazione del modello di membro viene visualizzato dopo. o -> in un'espressione postfissa, o dopo l'identificatore-nome-annidato in un id-qualificato, e l'espressione-postfissa o id-qualificato dipende esplicitamente da un parametro-modello (14.6.2), il nome del modello membro deve essere preceduto dal modello di parole chiave . In caso contrario, si presume che il nome denomini un non modello.

In t->f0<U>(); f0<U>è una specializzazione del modello di membro che appare dopo ->e che dipende esplicitamente dal parametro del modello U, quindi la specializzazione del modello di membro deve essere preceduta da una templateparola chiave.

Quindi cambia t->f0<U>()in t->template f0<U>().

Oltre ai punti fatti da altri, si noti che a volte il compilatore non riesce a prendere una decisione ed entrambe le interpretazioni possono fornire programmi validi alternativi durante l'istanza

#include <iostream>

template<typename T>
struct A {
  typedef int R();

  template<typename U>
  static U *f(int) { 
    return 0; 
  }

  static int f() { 
    return 0;
  }
};

template<typename T>
bool g() {
  A<T> a;
  return !(typename A<T>::R*)a.f<int()>(0);
}


int main() {
  std::cout << g<void>() << std::endl;
}

Viene stampato 0quando si omette templateprima f<int()>ma 1quando lo si inserisce. Lo lascio come esercizio per capire cosa fa il codice.

Inseriscilo appena prima del punto in cui si trova il cursore:

template<typename T, typename U, int N> struct X {
     void f(T* t)
     {
        t->template f0<U>();
     }
};

Modifica: il motivo di questa regola diventa più chiaro se pensi come un compilatore. I compilatori generalmente guardano avanti solo uno o due token contemporaneamente e generalmente non "guardano avanti" al resto dell'espressione. [Modifica: vedi commento] Il motivo della parola chiave è lo stesso del motivo per cui hai bisogno della typenameparola chiave per indicare i nomi dei tipi dipendenti: sta dicendo al compilatore "ehi, l'identificatore che stai per vedere è il nome di un modello, piuttosto che il nome di un membro di dati statici seguito da un segno di minore di ".

Estratto dai modelli C ++

Il costrutto .template Un problema molto simile è stato scoperto dopo l'introduzione di typename. Considera il seguente esempio utilizzando il tipo di set di bit standard:

template<int N> 
void printBitset (std::bitset<N> const& bs) 
{ 
    std::cout << bs.template to_string<char,char_traits<char>, 
                                       allocator<char> >(); 
} 

Lo strano costrutto in questo esempio è .template. Senza questo uso aggiuntivo del modello, il compilatore non sa che il token minore di (<) che segue non è realmente "minore di" ma l'inizio di un elenco di argomenti del modello. Notare che questo è un problema solo se il costrutto prima del periodo dipende da un parametro del modello. Nel nostro esempio, il parametro bs dipende dal parametro del modello N.

In conclusione, la notazione .template (e notazioni simili come -> template) dovrebbe essere usata solo all'interno dei template e solo se seguono qualcosa che dipende da un parametro del template.