Modello di classe nel modello di classe in C++

Question

qui ancora sperimentando con i modelli. Cercando di scrivere un modello di classe di elaborazione 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_ 

}; 

Tutto definito 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 di intestazione necessari per definire cos'è un MessageType. Ho usato questa funzione molto tempo prima, ma non in questo contesto.

Sospetto che il compilatore non apprezzi il fatto che la funzione template sia completamente definita (specializzata?) All'interno di un modello di classe non definito (non specificato?). Non sono completamente soddisfatto di ciò che rende un modello "specializzato". La maggior parte delle spiegazioni si concentra sui concetti di "pieno" o "parziale", ma non su ciò che lo rende specializzato in primo luogo.

Scusa se desideri vedere più codice. Non ho accesso a Internet sul posto di lavoro, ed è qui che sto facendo questo, quindi devo mettere tutto nel mio "blockpad" mentale e portarlo a casa.

Answer 1

La 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 di modello generico)

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

Forse questo esempio ti aiuterà ad apprezzare quando un modello membro necessita di per essere preceduto dalla parola chiave 'template' [Nota: nell'interesse della simmetria puoi sempre usare il prefisso 'template' sui template dei membri, ma è facoltativo se utilizzato su 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 

    } 

}; 

Spero che questo aiuti.

Answer 2

Probabilmente, MessageType non è noto in quel punto. Ti manca un'inclusione, una risoluzione dello spazio dei nomi o una dichiarazione?

se non è così, come viene dichiarato getMessageSender e come è MessageType?

Generalmente, in C++ non è un problema se T non è noto in quel punto (beh ... è complicato, ma comunque).

Inoltre, il messaggio di errore contiene in genere il tipo per il quale si tenta di essere insorto. Prova a pubblicare il messaggio di errore completo almeno.

Answer 3

Avete altre chiamate simili a metodi come getMessageSender che sono templatizzati?

t_->getMessageSender<MessageType>(); 

Answer 4

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

t_->template 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" del tuo strumento per argomenti specifici del modello. Un esempio: std::vector è la versione specializzata del generico std::vector.

Una specializzazione parziale è un'implementazione del codice generico in cui non vengono forniti tutti gli argomenti del modello.

Answer 6

Questo funziona perfettamente sul compilatore di Visual Studio 2010.

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 aggiornata la risposta !!!