Bonjour,

je suis actuellement en train d'implémenter une abstract factory un peu particuliere qui aura pour but de parser des données entrantes, obtenir un identifiant de cet étape de parse, chercher dans un std::map (static) la factory attaché à cette idéntifiant et de créer un objet.
La petite difficulté supplémentaire est de faire en sorte que chaque factory puisse faire un callback sur l'objet appellant le parser.

Maintenant que le décor est à peu près planté voici mon soucis, mon code est valide et se compile mais je tombe sur une erreur de link dans laquelle il m'indique que mon std::map n'est pas défini.

Je ne sais pas si la présentation du problème est très claire ( pas facile à expliquer en fait ) mais voici le code source du principe que j'aimerai mettre en place ( c'est une version très light de mon autre implémentation mais surement plus lisible ) merci à ceux qui se pencheront dessus.

Code : Sélectionner tout - Visualiser dans une fenêtre à part
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
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
 
#include <iostream>
#include <map>
using namespace std;
 
 
 
class C_impl
{
public :
    C_impl()
    { }
    ~C_impl()
    { }
};
 
template<class T>
class A
{
 
public :
 
    static void parse(T& u, uint16_t id)
    {
 
        iter it = m_factories.find(id);
        if (it == m_factories.end())
            return;
 
        (*it).second->create(u);
 
    }
 
 
    class factory
    {
 
    public :
        virtual void create(T& u) = 0;
 
    protected :
        factory(uint16_t id)
        {
 
            A::m_factories.insert(std::make_pair(id, this));
        }
 
        virtual ~factory()
        { }
 
    };
private :
    A()
    { }
    ~A()
    { }
    typedef typename std::map<uint16_t,factory*>::iterator iter;
    static std::map<uint16_t, factory*> m_factories;
 
 
};
 
 
template<class T>
class C_factory : public A<T>::factory
{
 
public :
    C_factory() : A<T>::factory(0x0001)
    { }
 
    virtual void create(T& u)
    {
        u.on_event(C_impl());
    }
};
 
class user
{
 
public :
 
    user()
    { }
    ~user()
    { }
 
 
private :
    void on_event(const C_impl& c)
    {}
 
    friend class C_factory<user>;
};
 
 
int main()
{
 static C_factory<user> c_f;
 
 return 0;
 
}