Wie kann ich instanziiert Klasse mit Funktionszeiger als Vorlage arg

Question

Ich habe

template <void (*T)(Entity *), typename Caller> 
class Updater 
{ 
public: 
    Updater(Caller c):m_caller(c){} 
    void process(Entity * e) 
    { 
     (m_caller->*T)(e);    //Is this right? 
    } 
private: 
    Caller m_caller; 
}; 

Ich verstehe ich es wie

Foo f; 
Updater<&Foo::Bar> updater(&f); 

instanziiert kann unter der Annahme, dass Foo hat

void Foo::Bar(Entity *e); 

aber Was ist, wenn es die gewünschte Methode tempiert hat? So,

template <typename T> 
void Bar(T t); 

Wie sollte ich es installieren? So was:?

Foo f; 
Updater<&Foo::Bar<Entity *>> updater(&f); 

Wenn ich das tue in meinem echten Code, ich

bekommen

invalid template argument for ..., expected compile-time constant expression

So 2 Fragen:

1 ist (m_caller->*T)(e); richtig? Wenn nicht, wie rufe ich es an?

2, wie kann ich es instanziieren?

Answer 1

template <typename Caller, void (Caller::*Func)(Entity *)> 
class Updater 
{ 
public: 
    Updater(Caller *c):m_caller(c){} 
    void process(Entity * e) 
    { 
     (m_caller->*Func)(e); // use pointer to member operator ->* 
    } 
private: 
    Caller *m_caller; 
}; 

// call like this 
Foo f; 
Updater<Foo, &Foo::Bar> updater(&f); 

Answer 2

edit:

user2k5 bearbeitet seine Antwort, so nahm ich es.

meiner früheren msg:

Dank user2k5 ich die richtige Arbeits Code herausgefunden,

Arbeitsprobe folgt: (foo2 kann durch Foo ersetzt werden)

#include <iostream> 

struct Entity { int i; }; 

template < typename Caller, void (Caller::*Func)(Entity *)> 
class Updater 
{ 
public: 
    Updater(Caller *c):m_caller(c){} 
    void process(Entity * e) 
    { 
     (m_caller->*Func)(e); 
    } 
private: 
    Caller *m_caller; 
}; 

struct Foo 
{ 
    void bar(Entity * e) 
    { 
     std::cout << e->i << std::endl; 
    } 
}; 

struct Foo2 
{ 
    template <typename T> 
    void bar(T t) 
    { 
     std::cout << t->i << std::endl; 
    } 
}; 

int main() 
{ 
    Foo2 f; 
    Updater<Foo2, &Foo2::template bar<Entity *>> updater(&f); 
    Entity e; 
    e.i = 5; 
    updater.process(&e); 


    return 0; 
}