Discussion :

[Invité]

Bonjour,
J'ai réalisé un patite classe(template) permettant de stocker des objet de plusieurs types en évitant les pointeurs, l'allocation dynamique, les fonctions virtuelles...

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
 
template<class T>
struct MultyTypesContainer;
 
 
 
template<class T>
struct SingleTypeContainer
{
    void insert(const T& val)
    {
         set_.insert(val);
    }
 
    template<class Func>
    Func call_for_each(Func f)
    {
        return std::for_each(set_.begin(), set_.end(), f);
    }
 
private:
	std::set<T> set_;
};
 
 
template<class Head, class Tail>
struct MultyTypesContainer<Loki::Typelist<Head,Tail> >
{
    typedef typename Loki::Typelist<Head,Tail> TList;
    enum{size = Loki::TL::Length<TList>::value};
    typedef typename Loki::GenScatterHierarchy<TList,SingleTypeContainer> MultyTypesContainerImplementation;
    MultyTypesContainerImplementation impl_;
    template<class Func, int i>
    Func call_for_each(Func f, Loki::Int2Type<i>)
    {
        f = Loki::Field<i>(impl_).call_for_each(f);
	return call_for_each(f, Loki::Int2Type<i-1>());
    }
 
    template<class Func>
    Func call_for_each(Func f, Loki::Int2Type<0>)
    {
	return Loki::Field<0>(impl_).call_for_each(f);
    }
 
public:
    template<class T>
    void insert(const T& val)
    {
	impl_.SingleTypeContainer<T>::insert(val);
    }
    template<class Func>
    Func call_for_each(Func f)
    {
	return call_for_each(f, Loki::Int2Type<size-1>());
    }
};

Je voulais savoir si vous pensez qu'une classe comme celle-ci peut être utile ou au contraire qu'elle pourra encombrer un plus ma corbeille de projets ratés ?

PS: En appelant 500000 fois une fonction(membre) vide a partir d'un ensemble de 1000 objets j'ai entre 7% et 8% de gain de vitesse.

EDIT:
En fait, pour éviter d'écrire des tonnes de foncteur j'ai fait un petit macro

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
 
#define CALL_MEMBER_FUNCTION0(function) \
            struct \
	    { \
		template<class T>\
		void operator()(T& obj) \
		{\
	            obj.function(); \
	        }\
	    }

et je l'utilise avec un typedef :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
typedef CALL_MEMBER_FUNCTION0(get_statistics) GetSatisticsFunctor;
 
typedef MultyTypesContainer<Classe1, Classe2> Conteneur;
 
Conteneur stats;
stats.call_for_each(GetSatisticsFunctor());

Par contre je peux pas faire mon typedef(le premier) dans un fonction : les classes locales ne peuvent pas avoir de fonctions membres template.

PS2 : J'ai aussi codé un iterateur mais bon, vu ses performances, je vais éviter de le poster...

[Emmanuel Deloget]

Du point de vue d'un architecte, quelques questions :

1) dans quel cas est-ce que je peux avoir besoin d'une telle classe ? As-tu identifier un besoin clair (parce que la programmation pour la programmation, ça a quand même des limites... )?

2) Comment puis-je l'utiliser, une fois que j'ai mis des carottes et des presse-papiers dans le même sac ?

3) Comment faire pour récupérer une valeur dans ce conteneur ? (parce que bon, contenir des valeurs, c'est bien, mais un jour ou un autre il faudra les traiter...)

4) Que faire si les différents types stockés n'ont pas la même interface ? (c'est nécessaire pour l'utilisation du foncteur que tu donnes en exemple. Plus généralement, si tu comptes utiliser call_for_each() sur le conteneur entier, le foncteur que tu passes en paramètre
* doit être capable de retrouver, via par exemple des traits, les caractéristiques des différents types d'objet manipulés
* ou, au moins, être spécialisé pour traiter chacun des types d'objet manipulés.)

5) Si les différents types stockés ont la même interface, pourquoi est-ce le cas ?

D'autres questions peuvent survenir dans mon esprit torturé d'un instant à l'autre...

[poukill]

Quelle différence avec boost::variant ? C'est multi-type (disons prédéfinis). L'accès se fait via des visiteurs.
Je pense pas avoir besoin de plus que ça. D'ailleurs, comme le souligne Emmanuel, après on sait plus les traiter, non ?

[Invité]

Bonjour,
Tout d'abord merci pour vos réponse.
1) Je pensais avoir quelques cas:
*si on veut conserver le type exacte d'un objet(notamment lorsque on veut appeler un fonction utilisant de deux ces objets et mettant en place un comportement différent en fonction de leurs types; on pourrait utiliser un double dispatcher mais ça demanderait au mieux un static_cast, au pire un dynamic)
*si on veut éviter la surcharge de coût à l'éxecution

2)Je pensais aussi rajouter des accesseurs pour récupérer en fonction du type

3)Par un foncteur, non?

4)Honnêtement, je n'y avais pas pensé, mais c'est un bonne idée

5)Ca rejoint un peut tout les autres points

D'après ce que j'ai compris, boost::variant ne peut pas contenir à la fois "hello_world" et 5.0f .

En fait, ce "conteneur" part de ce principe : "il est inutile de faire du dynamique quand l'on peut faire du statique"

J'espère avoir été le plus explicite possible.Vos conseils vont sans doute me permettre de m'améliorer(ca sera pas plus mal).

[3DArchi]

Salut,
Boost.Variant est une 'union'. Ensuite tu peux avoir un conteneur classique (list, vector, map, etc.) de Boost.Variant pour avoir un conteneur hétérogène.

[Invité]

Alors oui, c'est pour l'instant le même fonctionnement(enfin un conteneur de boost::variant contient toutes les opérations du mien). Mais je pourrais "améliorer" le mien en rajoutant un fonction pour obtenir tout les objet d'un (ou plusieurs) type(s).

Je rajoute à mes cas d'utilisation : il est parfois désirable d'obtenir un conteneur triée en fonction du type(exact) des objets qu'il contient.