Wann sollte ich das Stichwort „Typname“ verwenden, wenn Vorlagen

Question

mit einer .h-Datei gegeben, die ich habe in letzter Zeit auf einem kleinen Projekt zu arbeiten, und ich konnte nicht herausfinden, etwas ..

Ich habe enthielt eine Klasse mit einer typenspezifischen Vorlage. In dieser Klasse gab es eine Privatklasse.

template <typename T> 
class Something 
{ 
public: 
     Something(); 
     ~Something(); 

     Node* Function1(int index); 
     int Index(const T& id); 


private: 
     class Node() 
     { 
       public: 
       T id; 

       //Imagine the rest for the Node 


     };  
}; 

Das Problem ist aufgetreten, wenn ich die Funktionen der Klasse "Something"

Hier ist, wie ich es tat (in einer .inl Datei)

template<typename T> 
Node* Something::Function1(int index) //Is the return type well written? 
{ 
     // returns the node at the specified index 
} 

template<typename T> 
int Something::Index(const T& id) //Is the parameter type well specified? 
{ 
     // returns the index of the node with the specified id 
} 

So ist die abhör definieren wollte Teil war im Definitionsteil ... Muss ich dem Compiler mitteilen, dass der Rückgabetyp (in diesem Fall Knoten *) die Typname-Vorlage verwendet (wie diese: typename Node*)? Und was ist mit dem Parameter? typename const Node&?

Also im Grunde, wann muss ich angeben, ob die Funktion/der Parameter eine Vorlage verwendet?

Danke für Ihre Zeit.

Answer 1

template<typename T> 
typename Something<T>::Node * Something::Function1(int index) //Is the return type well written? 
{ 
     // returns the node at the specified index 
} 

Answer 2

Die einfache Regel: Sie benötigen das typename Schlüsselwort, das Sie einen Typnamen mit der Class::Type Syntax jedes Mal verwenden, wenn der Class Teil auf einem Template-Parametern abhängig ist. (Der Class Teil könnte ein Vorlagenparameter sein oder ein typedef in Ihrer Klassenvorlage usw.)

Edit: Es gibt auch einige Verwirrung über geschachtelte Klassenbereichsregeln. Dies ist größtenteils unabhängig von dem typename Problem, also hier ist ein Beispiel ohne Vorlage.

class Outer { 
public: 
    class Inner { 
    }; 
    Inner* func(Inner* obj); 
}; 

Outer::Inner* func(Inner* obj) 
{ 
} 

Der vollständige Name von Inner ist Outer::Inner. Sie können aber auch den kürzeren Namen Inner überall im Bereich der Klasse Outer verwenden, einschließlich aller Deklarationen von func. Bei der Definition von func ist der Rückgabetyp NICHT im Bereich Outer, daher ist der vollständige Name erforderlich. Aber nach der (, sind die Funktionsparameter im Bereich Outer, so ist der kurze Name in Ordnung.

dies mit dem Template-ness des ursprünglichen Beispiel kombinierend, da das Äquivalent von OuterSomething<T> ist, müssen Sie die typename Schlüsselwort Something<T>::Node zu sagen.

Answer 3

Für Function1 müssen Sie dem Compiler mitteilen, welcher Knoten ist - in diesem Fall ist es ein verschachtelter Typ innerhalb Something<T>. Da es von T abhängig ist (es ist ein abhängiger Name), müssen Sie dem Compiler mitteilen, dass es sich um einen Typ handelt, also müssen Sie ihn als typename Something<T>::Node schreiben. Das Problem ist, dass es möglicherweise einige T für die ist nicht eigentlich ein Typ (d. H. Wenn Sie teilweise spezialisieren Something<T>).

Für Index, was Sie haben, ist in Ordnung - const T& ist nur ein Verweis auf eine const T, und der Compiler weiß, was T ist.

Answer 4

typename und class sind gleichwertig in Parameterliste Vorlagentyp:

template <class T> class C; 

ist die gleiche wie

template <typename T> class C; 

Wo die typename erforderlich ist, wenn es um dependent names:

template <typename T> struct A { 
    typedef typename T::some_type container; 
};