Dans l'article sur la métaprog on un exemple un peu cryptique :

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
 
template<bool Condition> struct Test {};
 
template<> struct Test<true>
{
    static void Do()
    {
        DoSomething();
    }
};
 
template<> struct Test<false>
{
    static void Do()
    {
        DoSomethingElse();
    }
};
Je me demande si le code suivant est lui aussi de la méta programmation :

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
 
template<bool cond> void choixMeta()
{
	if(cond) 
        	DoSomething();
	else 
        	DoSomethingElse();
}
Je constate un gain de performance mais moins fort que le code de l'article, fichier de test :
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
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
#include <iostream>
#include <windows.h>
 
using namespace std;
 
int maVarGlobale=0;
 
#define CODE  \
	if(cond) \
		maVarGlobale=1; \
	else \
		maVarGlobale=0;
 
 
void choixClassique(bool cond)
{
	CODE
}
 
template<bool cond> void choixMeta()
{
	CODE
}
 
template<bool Condition> struct choixMeta2 {};
template<> struct choixMeta2<true>
{
    static void Do()
    {
        maVarGlobale=1;
    }
};
 
template<> struct choixMeta2<false>
{
    static void Do()
    {
        maVarGlobale=0;
    }
};
 
 
class CPrecisionTimer
{
LARGE_INTEGER lFreq, lStart;
double duration;
 
public:
CPrecisionTimer()
{
QueryPerformanceFrequency(&lFreq);
}
 
inline void Start()
{
QueryPerformanceCounter(&lStart);
}
 
inline double Stop()
{
// Return duration in seconds...
LARGE_INTEGER lEnd;
QueryPerformanceCounter(&lEnd);
duration=(double(lEnd.QuadPart - lStart.QuadPart) / lFreq.QuadPart);
return duration;
}
 
inline double Duration()
{
	return duration;
}
 
};
 
void main()
{
	int nb=100000000;
 
    CPrecisionTimer timer;
	bool cond;
 
	timer.Start();    
	for(int i=0;i<nb;++i)
	{
		choixClassique(true);
		choixClassique(true);
		choixClassique(true);
		choixClassique(true);
		choixClassique(true);
		choixClassique(false);
		choixClassique(false);
		choixClassique(false);
		choixClassique(false);
		choixClassique(false);
	}
	timer.Stop();   
	cout<<"Duree de choix classique="<<timer.Duration()<<endl;
 
 
 
	timer.Start(); 
	for(int i=0;i<nb;++i)
	{
		choixMeta<true>();
		choixMeta<true>();
		choixMeta<true>();
		choixMeta<true>();
		choixMeta<true>();
		choixMeta<false>();
		choixMeta<false>();
		choixMeta<false>();
		choixMeta<false>();
		choixMeta<false>();
	}
	timer.Stop();   
	cout<<"Duree de choix meta="<<timer.Duration()<<endl;
 
 
 
	timer.Start(); 
	for(int i=0;i<nb;++i)
	{
		choixMeta2<true>::Do();
		choixMeta2<true>::Do();
		choixMeta2<true>::Do();
		choixMeta2<true>::Do();
		choixMeta2<true>::Do();
 
		choixMeta2<false>::Do();
		choixMeta2<false>::Do();
		choixMeta2<false>::Do();
		choixMeta2<false>::Do();
		choixMeta2<false>::Do();
	}
	timer.Stop();   
	cout<<"Duree de choix meta2="<<timer.Duration()<<endl;
 
	system("pause");
 
}
J'ai dupliqué les appels pour voir un peu plus l'impact de l'astuce sur les temps d'execution, plutôt que de compter le temps passer à faire les boucles.

Sur mon pc j'obtiens

Duree de choix classique=31.6242
Duree de choix meta=29.7122
Duree de choix meta2=28.9344
Donc : le bout de code que je présente est-il bien de la méta prog (je pense) ?
De la méta prog "classieuse"? (je ne pense pas au vu des perfs)

Est-ce que l'exemple de l'article arriverait tout simplement à tellement métaprogrammer, qu'il évite l'appel de fonction ?