classe template all'interno modello di classe in C ++

Question

niubbo qui ancora sperimentando con i modelli. Cercando di scrivere un modello di classe di elaborazione dei messaggi

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_

};

Tutti definita in un file di intestazione. Ho costruito e testato la mia classe e tutto va bene. Ora, io sto cercando di fare questo:

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

Tuttavia, questa linea mi dà un errore di cattiva espressione di tipo prima di '>' token.

Ho aggiunto i file header necessari per definire ciò che un MessageType è. Ho usato questa funzione molte volte prima, non solo in questo contesto.

Ho il sospetto che il compilatore non piace il fatto che la funzione di modello è completamente definito (specializzato?) All'interno di un modello di classe indefinita (non specializzato?). Io non sono pienamente Grokking ciò che rende un modello di 'specializzata'. La maggior parte delle spiegazioni centro sui concetti di 'pieno' o 'parziali', ma non ciò che lo rende specializzata in primo luogo.

Ci scusiamo se vuoi vedere più codice. Non ho accesso a Internet sul posto di lavoro ed è lì che sto facendo questo, quindi devo mettere tutto nel mio 'scratchpad' mentale e portarla a casa.

Answer 1

La vostra funzione membro 'pippo' ha bisogno di un tipo di ritorno ed è necessario utilizzare la parola chiave 'modello' quando si utilizzano modelli di membro nelle espressioni dipendenti (espressioni i cui significati si basano direttamente o indirettamente su un parametro modello generico)

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

Forse questo esempio vi aiuterà ad apprezzare quando un modello di membro deve per essere preceduto dal 'modello' parola chiave [Nota: nell'interesse della simmetria si può sempre utilizzare il prefisso 'modello' per gli Stati modelli, ma è facoltativo quando viene utilizzato in un'espressione non-dipendente.

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

  }

};

La speranza che aiuta.

Answer 2

Aggiungere la parola chiave template tra il -> e il nome del metodo template:

t_->template getMessageSender<MessageType>();

Answer 3

Probabilmente, MessageType non è noto in quel punto. Vi manca un include, risoluzione dello spazio dei nomi o di una dichiarazione?

se tht non è tutto, come viene getMessageSender dichiarato, e come è MessageType?

In generale, in C ++ non è un problema se T non è noto a quel punto (beh ... è complicato, ma ancora).

Inoltre, il messaggio di errore di solito contiene il tipo per il quale si cerca di essere insantiated. Prova a inviare il messaggio di errore completo almeno.

Answer 4

Hai altre chiamate simili a metodi come getMessageSender che sono templatized?

t_->getMessageSender<MessageType>();

Answer 5

E 'solo il tipo di ritorno della funzione che manca. Il membro t_ è completamente definito.

Una specializzazione di un modello è una versione 'speciale' il vostro attrezzo per gli argomenti modello specifico. Un esempio:. std::vector è la versione specializzata del std::vector generica

Una specializzazione parziale è un'implementazione del vostro codice generico in cui non sono forniti tutti gli argomenti di template.

Answer 6

Questo funziona bene su Visual Studio 2010 compilatore.

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

Solo per mantenere la risposta aggiornato !!!