Double specialisation d'une classe templatée

[DakM]

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

[koala01]

Salut,

A vrai dire, je ne suis pas sur de comprendre ce que tu entend par "double spécialisation", mais...

Si, comme je le crois, l'idée est de pouvoir avoir une spécialisation pour le cas ou la touche shift est enfoncée, une autre pour le cas ou la touche ctrl est enfoncée et une troisième pour le cas où les deux sont enfoncées, il "suffit" de faire en sorte que tes spécialisations respectent tes besoins, sous une forme proche de

Code :

1
2
3
4
5
6
7
8
9
10
11
12
struct ShiftDown
{
    /*ce qui va bien*/
};
struct CtrlDown
{
    /* ce qui va bien */
};
struct CtrlAndShiftDown
{
    /*ce qui va bien */
};

Ceci dit, je ne résiste pas à l'envie de rappeler le conseil de David Wheeler:

Envoyé par David Wheeler

all problems in computer science can be solved by another level of indirection .