abstract factory pattern

Bonjour
Il y a qqch qui m'échappe avec les factory pattern
Les exemples que j'ai vus
http://www.enib.fr/~buche/public/ens...on/pattern.pdf
ou encore http://advancedcppwithexamples.blogs...n-pattern.html semblent m'indiquer que la fabrique va creer des objets sans parametres.

Dans mon cas j'ai une classe mere (virtuelle) Instrument et des classe filles concretes obligation, equity
Or pour chacunes des classes filles, je vais avoir des parametres à introduire (parametres qui definissent l'objet)
Exemple: obligation est definie par son coupon et sa date de remboursement et equity est défini par son dividende et son emetteur)
Si j'essaye de mettre en pratique le pattern factory pour cette histoire comment puis je introduire ces caractéristiques?
J'ai l'impression que c'est pas possible ou du moins je vois pas comment
Merci bcp

J'ai trouvé ceci qui peut peut erte apporter sa pierre à l'édifice (source: http://www.codeguru.com/forum/showthread.php?t=428208)

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
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
#include <iostream>
#include <string>
#include <map>
 
template<class BaseT>
class ICreator;
 
template<class C>
class Creator;
 
 
class AX 
{
public:
    AX(int a, char b, float c) {}
};
 
class AX_1 : public AX 
{
public:
    AX_1(int a, char b, float c) : AX(a,b,c) {}
};
class AX_2 : public AX
{
public:
    AX_2(int a, char b, float c) : AX(a,b,c) {}
};
 
 
class BX
{
public:
    BX(double a, char b) {}
};
 
class BX_1 : public BX
{
public:
    BX_1(double a, char b) : BX(a,b) {}
};
 
class BX_2 : public BX 
{
public:
    BX_2(double a, char b) : BX(a,b) {}
};
 
 
 
template<class BaseT>
class Factory_Plant
{
    typedef std::map<std::string, ICreator<BaseT>* > dictionary_t;
    dictionary_t dict;
public:
    bool Register(const std::string id, ICreator<BaseT>* cr)
    {
        return dict.insert( dictionary_t::value_type(id, cr) ).second;
    }
 
    ICreator<BaseT>* Create(const std::string& id) const
    {
        typename dictionary_t::const_iterator it = dict.find(id);
        if( it!= dict.end() )
            return it->second;
        else
            return NULL;
    }
};
 
template<>
class ICreator<AX>
{
public:
    virtual AX* operator()(int a, char b, float c) = 0;
};
 
template<class C>
class AXCreator : public ICreator<AX>
{
public:
    AX* operator()(int a, char b, float c)
    {
        return new C(a,b,c);
    }
};
 
 
template<>
class ICreator<BX>
{
public:
    virtual BX* operator()(double a, char b) = 0;
};
 
template<class C>
class BXCreator : public ICreator<BX>
{  
public:
    BX* operator()(double a, char b)
    {
        return new C(a, b);
    }
};
 
 
int main()
{
    Factory_Plant<AX> fact_ax;
    fact_ax.Register("ax1_create", new AXCreator<AX_1>() );
    fact_ax.Register("ax2_create", new AXCreator<AX_2>() );
 
    Factory_Plant<BX> fact_bx;
    fact_bx.Register("bx1_create", new BXCreator<BX_1>() );
    fact_bx.Register("bx2_create", new BXCreator<BX_2>() );
 
    (* fact_ax.Create("ax1_create") )(1,'a',2.5); 
    (* fact_ax.Create("ax2_create") )(7,'G',6.1); 
 
    (* fact_bx.Create("bx1_create") )(3.458, 'y'); 
    (* fact_bx.Create("bx2_create") )(12.08, 'Z'); 
}

mais je suis pas certain de comprendre le but du Register..

Register enregistre un type au sein de la factory en l'associant à une clé de type string. Une fois enregistré la demande creat(string) renvoit l'objet de bon type.