Double specialisation d'une classe templatée

Bonjour,

Je tente de faire une double specialisation sur une classe templatée
Voici une version courte de la classe:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
 
class GameManager;
 
template<class Specialisation, class Argument>
class KeyboardHandler
{
public:
    enum Type
    {
        KeyDown = 1,
        KeyUp,
        KeyPress
    };
 
    typedef void(KeyboardHandler::*handlerk)(const Type& type, Argument& arg);
 
    KeyboardHandler(GameManager& gm, Specialisation& scr) :
        m_game(gm),
        m_screen(scr),
        init(false),
        last_event()
    {
        /// Arrows
        handlers[sf::Keyboard::Key::Left] = &KeyboardHandler::Left;
        handlers[sf::Keyboard::Key::Right] = &KeyboardHandler::Right;
        handlers[sf::Keyboard::Key::Up] = &KeyboardHandler::Up;
    }
 
    virtual ~KeyboardHandler()
    {
        handlers.clear();
    }
 
 
    void handleKeys(const sf::Event& event, Argument& arg)
    {
        if(!init)
        {
            last_event = event;
            init = true;
        }
        const short key = static_cast<short>(event.key.code);
 
        if(handlers.find(key) != std::end(handlers))
        {
 
            if(event.type == sf::Event::EventType::KeyPressed
               && last_event.type == sf::Event::EventType::KeyPressed)
            {
                (this->*handlers[key])(Type::KeyPress, arg);
            }
            else if(event.type == sf::Event::EventType::KeyPressed
               && last_event.type != sf::Event::EventType::KeyPressed)
            {
                (this->*(handlers[key]))(Type::KeyDown, arg);
            }
            else if(event.type == sf::Event::EventType::KeyReleased)
            {
                (this->*(handlers[key]))(Type::KeyUp, arg);
            }
            last_event = event;
        }
    }
private:
 
    void inlinit();
 
    GameManager& m_game;
    Specialisation& m_screen;
 
    bool init;
    sf::Event last_event;
 
    std::unordered_map<short, handlerk> handlers;
 
    void Left(const KeyboardHandler::Type& type, Argument& arg);
    void Right(const KeyboardHandler::Type& type, Argument& arg);
    void Up(const KeyboardHandler::Type& type, Argument& arg);
    void Down(const KeyboardHandler::Type& type, Argument& arg);
 
 
};

Je voudrais pouvoir appeler donc une certaine touche du clavier avec deux arguments different, d'où une double specialisation

En revanche, je bidouille un peu sur la définition, mais je vois pas comment.

Pour une specialisation simple c'est:

template<>
void KeyboardHandler<PremiereSpecialisation>::Up(const KeyboardHandler::Type& type);

Mais pour deux ?

Aussi, il faut que je puisse mettre ces definitions dans plusieurs fichiers .cpp séparés, d'où l'impossibilité de definir ces templates dans le header

Sauriez vous m'aider ?

merci d'avance,

nico