Template-Klasse innerhalb Klassenvorlage in c ++

Question

Noob hier experimentieren noch mit Vorlagen. Der Versuch, eine Nachrichtenverarbeitung Klassenvorlage zu schreiben

template <typename T> class MessageProcessor {

  //constructor, destructor defined
  //Code using t_ and other functions
foo( void ) {

//More code in a perfectly fine method
}
  private:  T *t_

};

Alle in einer Header-Datei definiert. Ich habe gebaut und getestet meine Klasse und alles ist gut. Nun, ich versuche, dies zu tun:

template <typename T> class MessageProcesor {

  //Same stuff as before

foo(void) {
//Same code as before in foo, but one new line:
  t_->getMessageSender<MessageType>();

}

private: T *t_;
};

Allerdings gibt diese Zeile mir einen Fehler von schlechten Ausdruck-Typ vor dem ‚>‘ Token.

Ich habe die notwendigen Header-Dateien hinzugefügt, um zu definieren, was ein Message ist. Ich habe vor dieser Funktion viele Zeit verwendet, nur nicht in diesem Zusammenhang.

Ich vermute, dass der Compiler nicht die Tatsache mag, dass die Template-Funktion vollständig (spezialisiert?) Definiert ist, innerhalb einer nicht definierten Klassen-Template (unspezialisiert?). Ich grokking nicht vollständig, was eine Vorlage ‚spezialisiert‘ macht. Die meisten Erklärungen Zentrieren auf den Begriffen ‚voll‘ oder ‚teilweise‘, aber nicht das, was macht es in erster Linie spezialisiert.

Entschuldigt, wenn Sie möchten, dass mehr Code sehen. Ich habe keinen Internetzugang bei der Arbeit und das ist, wo ich das tue, so habe ich alles in meine geistige ‚Scratchpad‘ setzen und nach Hause zu bringen.

Answer 1

Ihre Memberfunktion ‚foo‘ braucht einen Rückgabetyp und Sie müssen das Schlüsselwort ‚Vorlage‘ verwenden, wenn Sie Mitglied Vorlagen in der abhängigen Ausdrücke (Ausdrücke, deren Bedeutung verläßt direkt oder indirekt auf einem generischen Template-Parametern)

verwenden

t_->template getMessageSender<MessageType>();  // ok
t_->getMessageSender<MessageType>(); // not ok

Vielleicht ist dieses Beispiel werden Ihnen helfen, zu schätzen wissen, wenn ein Mitglied template muss von der ‚Vorlage‘ Schlüsselwort [Anmerkung vorangestellt werden: im Interesse der Symmetrie immer den ‚Vorlage‘ Präfix auf Mitglied verwenden Vorlagen, aber es ist optional, wenn auf einer nicht-abhängige Expression verwendet wird.

struct MyType
{  
  template<class T> void foo() { }
};

template<class U>
struct S
{
  template<class T>
  void bar()
  {
    MyType mt;  // non-dependent on any template parameter
    mt.template foo<int>(); // ok
    mt.foo<int>();  // also ok

    // 't' is dependent on template parameter T
    T t;
    t.template foo<int>();    // ok
    t.foo<int>(); // not ok

    S<T> st; // 'st' is dependent on template parameter T
    st.template foo<int>();    // ok
    st.foo<int>(); // not ok


    S<MyType> s;  // non-dependent on any template parameter
    s.bar<int>(); // ok
    s.template bar<int>(); // also ok

  }

};

Ich hoffe, das hilft.

Answer 2

Fügen Sie das Schlüsselwort template zwischen -> und dem Namen der Template-Methode:

t_->template getMessageSender<MessageType>();

Answer 3

Wahrscheinlich wird Message nicht an diesem Punkt bekannt. Sind Sie fehlt ein, einen Namespace-Auflösung oder eine Erklärung?

Wenn tht ist es nicht, wie ist getMessageSender erklärt, und wie ist MessageType?

Im Allgemeinen wird in C ++ ist es kein Problem, wenn T nicht an diesem Punkt bekannt ist (na ja ... es ist kompliziert, aber immer noch).

Auch enthält die Fehlermeldung in der Regel die Art, für die versucht wird, insantiated werden. Versuchen Sie, die vollständige Fehlermeldung zumindest zu veröffentlichen.

Answer 4

Haben Sie ähnliche Anrufe Methoden wie getMessageSender haben, die templatized werden?

t_->getMessageSender<MessageType>();

Answer 5

Es ist nur der Rückgabetyp Ihrer Funktion, die fehlt. Das t_ Mitglied ist vollständig definiert sind.

Eine Spezialisierung einer Vorlage ist eine ‚spezielle‘ Version Ihres für bestimmte Vorlage Argumente implementieren. Ein Beispiel:. std::vector ist die spezielle Version des generischen std::vector

Eine partielle Spezialisierung ist eine Implementierung des generischen Code, in dem nicht alle Vorlage Argumente angegeben werden.

Answer 6

Dies funktioniert auf Visual Studio 2010-Compiler.

class One
{
public:
    void newFoo() ;
    template < class T > void foo()
    {
        T obj ;  // obj is dependent on template parameter
        obj.newFoo() ;  // and this works
    }
}

Just zu halten, die Antwort aktualisiert !!!