Verwirrender Vorlagenfehler

Ich habe eine Weile mit Clang gespielt und bin auf "test / SemaTemplate / Dependent-Template-Recovery.cpp" (in der Clang-Distribution) gestoßen, das Hinweise zur Wiederherstellung nach einem Vorlagenfehler geben soll.

Das Ganze lässt sich leicht auf ein minimales Beispiel reduzieren:

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

Die Fehlermeldung von clang:

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

... Aber es fällt mir schwer zu verstehen, wo genau man das templateSchlüsselwort einfügen soll , damit der Code syntaktisch korrekt ist?

ISO C ++ 03 14.2 / 4:

Wenn der Name einer Mitgliedervorlagenspezialisierung nach angezeigt wird. oder -> in einem Postfix-Ausdruck oder nach einem verschachtelten Namensbezeichner in einer qualifizierten ID, und der Postfix-Ausdruck oder die qualifizierte ID hängt explizit von einem Vorlagenparameter (14.6.2) ab, muss der Name der Mitgliedsvorlage sein vorangestellt von der Keyword-Vorlage . Andernfalls wird angenommen, dass der Name eine Nichtvorlage benennt.

In t->f0<U>(); f0<U>ist eine Mitgliedervorlagenspezialisierung, die nach angezeigt wird ->und explizit vom Vorlagenparameter abhängt. UDaher muss der Mitgliedervorlagenspezialisierung das templateSchlüsselwort vorangestellt werden .

Also wechseln Sie t->f0<U>()zu t->template f0<U>().

Beachten Sie zusätzlich zu den Punkten, die andere angesprochen haben, dass sich der Compiler manchmal nicht entscheiden konnte und beide Interpretationen beim Instanziieren zu alternativen gültigen Programmen führen können

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

Dies wird gedruckt, 0wenn Sie es templatevorher weglassen, f<int()>aber 1wenn Sie es einfügen. Ich lasse es als Übung, um herauszufinden, was der Code tut.

Fügen Sie es kurz vor dem Punkt ein, an dem sich das Caret befindet:

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

Bearbeiten: Der Grund für diese Regel wird klarer, wenn Sie wie ein Compiler denken. Compiler blicken im Allgemeinen nur auf ein oder zwei Token gleichzeitig und nicht auf den Rest des Ausdrucks. [Bearbeiten: siehe Kommentar] Der Grund für das Schlüsselwort ist derselbe, warum Sie das typenameSchlüsselwort benötigen , um abhängige Typnamen anzugeben: Es sagt dem Compiler: "Hey, die Kennung, die Sie sehen werden, ist der Name einer Vorlage und nicht der Name eines statischen Datenelements, gefolgt von einem Vorzeichen ".

Auszug aus C ++ - Vorlagen

Das .template-Konstrukt Ein sehr ähnliches Problem wurde nach der Einführung des Typnamens entdeckt. Betrachten Sie das folgende Beispiel mit dem Standard-Bitset-Typ:

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

Das seltsame Konstrukt in diesem Beispiel ist .template. Ohne diese zusätzliche Verwendung der Vorlage weiß der Compiler nicht, dass das folgende Token (<) nicht wirklich "kleiner als" ist, sondern der Anfang einer Vorlagenargumentliste. Beachten Sie, dass dies nur dann ein Problem ist, wenn das Konstrukt vor dem Zeitraum von einem Vorlagenparameter abhängt. In unserem Beispiel hängt der Parameter bs vom Vorlagenparameter N ab.

Zusammenfassend sollte die .template-Notation (und ähnliche Notationen wie -> template) nur innerhalb von Templates verwendet werden und nur, wenn sie etwas folgen, das von einem Template-Parameter abhängt.