container<T> sans contrainte sur T
J'ai une classe qui gère un conteneur d'objets T. Je souhaite que ma classe n'impose pas de contraintes sur T, ou le moins possible.
Voici à quoi ressemble la classe:
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
| template<class T>
class MyContainer
{
...
container<mystery<T>::mystery_type> items;
public:
...
ret_val<T> foo(param_type ...)
{
...
if (some_condition)
{
...
void *vptr=acquire_some_memory(...);
T *p=new(vptr) T;//<--contrainte ici
items.insert(..., *p);
...
}
...
}
}; |
En l'état actuel, la seule contrainte est la nécessité pour T d'avoir un constructeur par défaut (pas de copy constructor, pas d'assign operator, ni aucun autre operator).
J'aimerais aller plus loin en supprimant cette dernière contrainte sans changer le prototype de la méthode foo(). Je pense que c'est possible en faisant un peu comme les factory de boost (dans le code, on suppose que T ne possède qu'un seul constructeur qui exige 3 paramètres):
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
| template<class T>
class factory
{
context & c_;
public:
factory(context & c): c_(c) {}
T *operator()(void *vptr)
{
...
return new(vptr) T(c_.a1, c_.a2, c_.a3);
}
};
template<class T>
class MyContainer
{
...
container<mystery<T>::mystery_type> items;
factory<T> f;
public:
MyClass(..., factory<T> & fact, ...): f(fact), ... {...}
...
ret_val<T> foo(param_type ...)
{
...
if (some_condition)
{
...
void *vptr=acquire_some_memory(...);
T *p=f(vptr);//<--contrainte déplacée dans factory<T>
items.insert(..., *p);
...
}
...
}
}; |
factory<T> serait donc un foncteur qui gèrerait la construction de T en fonction des besoins de ce dernier.
Y a-t-il mieux ?
Merci.
