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...