Chapitre 3 Métaprogrammation statique

1. Définition de la meta programmation

La métaprogrammation, nommée par analogie avec les métadonnées et

les métaclasses], désigne l'écriture de programmes qui manipulent des données
décrivant elles-mêmes des programmes. Dans le cas particulier où le programme
manipule ses propres instructions, on parle de programme auto-modifiant.
Elle peut être employée pour générer du code interprété par un compilateur et
donner un résultat constant, afin d'éviter un calcul manuel. Il permet également de
réduire le temps d'exécution du programme si le résultat constant avait été
classiquement calculé par le programme comme pour les résultats variables.
Cette méthode ne s'applique pas uniquement aux calculs mais aussi au remplissage
de données constantes telles que des tableaux ou des structures plus complexes.
Cependant cette technique ne fonctionne que pour des valeurs constantes. En effet,
si une donnée manipulée par le métaprogramme est une entrée du programme, par
exemple une saisie de l’utilisateur, elle ne peut pas être connue avant l'exécution du
programme. Il est donc impossible qu'un tel métaprogramme soit interprété par un
compilateur. L'optimisation par métaprogrammation est alors totalement perdue.

2. La base de la meta-programmation : les templates

La meta-programmation en C++ s'appuie sur un concept puissant de ce langage : les

templates. Avec l'arrivée des templates, le C++ s'est doté d'un outil aussi puissant
que complexe. En effet au travers de fonctions et classes templates nous sommes
maintenant capables d'écrire du code qui sera interprété non pas à l'exécution, mais
pendant la compilation. Un peu comme les macros en C, mais juste un peu : les
templates sont beaucoup plus complexes et puissantes.

Habituellement on se sert des templates pour créer des classes ou fonctions

génériques, c'est-à-dire qui acceptent n'importe quel type pour peu qu'il soit
compatible avec le code produit.

La meta-programmation consiste à manipuler des données génériques et mettre à

contribution notre compilateur pour générer le code final voulu. Ainsi tout ce que
nous allons voir par la suite se passe principalement pendant la phase de
compilation, l'exécution des programmes ne servira qu'à vérifier que notre
compilateur a bien généré le résultat attendu. L'un des inconvénients direct de ce
genre de programmation est donc un temps de compilation nettement accru, mais ce
n'est rien en comparaison de tout le temps gagné finalement : aussi bien à l'écriture
du code que pendant l'exécution du programme. Un autre inconvénient est qu'ici tout
ce que nous allons écrire devra être connu du compilateur : certaines données que
nous allons manipuler ne pourrons assurément pas être entrées par l'utilisateur lors
de l'exécution.

Habituellement templates sont utilisés pour écrire des fonctions et classes acceptant
plusieurs types, qui engendre une économie de temps et de réécriture. Mais ils
peuvent etre utilisés en meta-programmation :

 On peut faire faire tout un tas de calculs mathématiques à notre compilateur :

sinus, exponentielle, factorielle… et booster les performances de ce genre de
calculs généralement lents ;
 On peut réécrire des programmes habituellement pauvres en performances et
leur donner un second souffle, par exemple le tri-bulle (bubble sort) ;
 On peut procéder à des optimisations intéressantes et certainement
insoupçonnées sur nos calculs, notamment le calcul matriciel avec
lesexpression templates ;
 On peut générer automatiquement du code, notamment pour implanter
des design patterns tels que les fabriques ou le visiteur sans effort et en
gardant un typage fort ;
 On peut écrire des outils puissants tels que des analyseurs syntaxiques.

3. Métaprogrammation et Calcul et optimisation mathématique

L'un des exemples les plus célèbres et « simples » de fonction mathématique
remaniée à la sauce template est certainement la factorielle

template<unsigned int N> struct Fact

{
enum {Value = N * Fact<N - 1>::Value};
};
template<> struct Fact<0>
{
enum {Value = 1};
};

// Ici, x vaudra 24 avant même que vous ne lanciez votre programme - coût à
l'exécution : 0 sesterce
unsigned int x = Fact<4>::Value;
la syntaxe de la meta-programmation est un peu particulière, pleine de
spécialisations et d'enum comme vous n'avez pas l'habitude d'en voir. Nous allons
donc voir quelques règles de base de cette syntaxe un peu particulière. :
3.1. Quelques règles de meta-programmation
Comme tout type de programmation, la meta-programmation se base sur certaines
règles et une certaine syntaxe. La règle de base est que tout doit toujours rester au
maximum connu du compilateur. Si vous introduisez du code ne pouvant être évalué
qu'à l'exécution, soit votre meta-programme est cassé et le compilateur ne se gêne
pas pour vous le faire remarquer, soit c'est voulu (on ne peut pas toujours tout
précalculer), et dans ce cas cela s'en ressentira sur l'exécution du programme. Il faut
donc suivre assez rigoureusement certains principes de base,

3.1.1. Utiliser struct & enum pour les constantes entières

On rappelle que tout ce qui est laissé à l'exécution n'est plus exploitable par notre
compilateur, et ce sont des informations que nos meta-programmes ne pourront
jamais exploiter. Nous pouvons donc oublier de passer nos paramètres à des
fonctions, tout comme récupérer nos résultats via la valeur de retour. Donc nos
fonctions seront désormais des classes (ou plutôt des structures, c'est équivalent
en C++ mais cela nous évitera d'écrire un fastidieux "public :" à répétition), et nos
valeurs de retour ne seront rien de moins que des types énumérés (enum).
Exemple
// Une fonction totalement inutile : elle renvoit son paramètre
int Identite(int N)
{
return N;
}
unsigned int x = Identite(5); // x ne sera connu que lorsque le programme sera
exécuté

// La même en meta-programme
template<int N> struct Identite
{
enum {Value = N;}
};
unsigned int x = Identite<5>::Value; // la valeur de x est connue de notre compilateur

1. template<int V> struct factorielle

2. {
3. enum { value=V*factorielle<V-1> };
4. };
5.
6. template<> struct factorielle<0>
7. {
8. enum { value=1 };

};
Maintenant, nous voulons évaluez 11! :
Code :

1. int fact_11 = factorielle<11>::value;

Ce code enclenche une série d'évaluation :

Code :

1. int fact_11 = 11*factorielle<10>::value;

2. int fact_11 = 11*10*factorielle<9>::value;
3. ...
4. int fact_11 = 11*10*9*...*2*1 = 39916800;

Evidemment l'ensemble de ce code est produit et évalué à la compilation.

3.1.2. Les fonctions Inlines

Bien entendu nous ne travaillerons pas toujours avec des types entiers et des
constantes. Des fois on utilise des nombres réels et des variable qui ne peuvent etre
connu à l’execution. Nous disposons d'un moyen assez efficace : l'inlining. Une
fonction inline aura le même comportement qu'une macro : un appel à une telle
fonction se verra remplacé par le code correspondant, sans les inconvénients des
macros (comme l'évaluation multiple des paramètres entre autre). Attention toutefois,
l'inlining est totalement contrôlé par le compilateur, si votre fonction ne lui plait pas il
ne sera pas obligé de l'inliner. Même chose lorsque vous compilerez en mode debug
ou sans optimisation : il y a de fortes chances que vos fonctions ne soient pas
inlinées. Mais rassurez-vous : nos fonctions mathématiques ne feront pas plus d'une
ou deux lignes de code, ce qui en fait des candidates parfaites pour l'inlining, et il n'y
a donc aucune raison que votre compilateur n'en veuille pas.

inline int Add(int X, int Y)

{
return Y == 0 ? X : Add(X, Y - 1) + 1;
}

int Somme = Add(5, 3);

Ce code sera probablement remplacé par int Somme = 5 + 1 + 1 + 1 c'est-à-dire int

Somme = 8. S'il n'avait pas été inliné, il aurait abouti à des appels successifs à Add,
ce qui est très coûteux.

3.1.3. Les conditions : spécialisation et opérateur ternaire

ans nos programmes nous aurons très certainement besoin de tester certaines
conditions. Mais si nous utilisons le classique if / else, celui-ci ne pourra être évalué
qu'à l'exécution. Une solution est de créer une classe dont le paramètre template est
un booléen, puis de la spécialiser pour true et pour false, comme dans l'exemple ci-
dessous :

template<bool Condition> struct Test {};

template<> struct Test<true>

{
static void Do()
{
DoSomething();
}
};

template<> struct Test<false>

{
static void Do()
{
DoSomethingElse();
}
};

// Code habituel
if (Condition)
DoSomething();
else
DoSomethingElse();

// Avec notre structure Test

Test<Condition>::Do();

le principe de base de la meta-programmation : ici Condition devra pouvoir être

évaluée par le compilateur, sinon nous ne pouvons bien sûr pas utiliser ce
mécanisme.

Mais pour tester un booléen, nous pouvons également utiliser l'opérateur

ternaire ?: qui est parfois bien plus léger à écrire

template <int I> struct NumericTests

{
enum
{
IsPair = (I % 2 ? false : true),
IsZero = (I == 0 ? true : false)
 };
};

bool b1 = NumericTests<45>::IsPair; // 0 (false)

bool b2 = NumericTests<0>::IsZero; // 1 (true)

3.1.4. La récursion et la spécialisation pour boucler

Autre élément syntaxique d'importance : les boucles. Habituellement on utilse for et
autres while pour boucler , il va falloir faire sans si l'on veut que notre code soit
généré automatiquement (c'est-à-dire ici, nos boucles déroulées). Pour ce faire nous
allons utiliser la récusion (pour boucler) et la spécialisation (pour s'arrêter de
boucler).

template <int Begin, int End> struct Boucle

{
static void Do()
{
DoSomething();
Boucle<Begin + 1, End>::Do();
}
};

template <int N> struct Boucle<N, N>

{
static void Do() {}
};

// Méthode habituelle
for (int i = 5; i < 15; ++i)
DoSomething();

// Avec notre structure Boucle

Boucle<5, 15>::Do();

Exemple
for(int i=0;i<100000;i++) tab[i] = 2*i+1;
engendre 100000 tests et retours et affectations

1. for(int i=0;i<50000;i++)
2. {
3. tab[2*i] = 2*(2*i)+1;
4. tab[2*i+1] = 2*(2*i+1)+1;

}
avec ce code la boucle engendre 50000 tests et retours
et 100000 affectations

maintenant en utilisant ma métaprogrammation

1. // fonction de base
2. template<int N> void remplir( int* tab )
3. {
4. tab[N] = 2*N+1;
5. remplir<N-1>(tab);
6. }
7.
8. // fonction de terminaison
9. template<> void remplir<0>( int* tab )
10. {
11. tab[0] = 1;

Si nous l'appellons ainsi :

Code :

1. remplir<99>(tab);

Le code suivant est produit à la compilation :

Code :

1. tab[99] = 199;
2. tab[98] = 197;
3. tab[97] = 195;
4. ...
5. tab[2] = 5;
6. tab[1] = 3;
7. tab[0] = 1;

Gain de vitesse notable (proche du x2 ou du x3) mas evidemment perte sur la taille
de l'executable.

3.2 Réécriture des fonctions mathématiques

les templates peuvent nous aider à réécrire certains calculs mathématiques de
manière inhabituelle et beaucoup plus optimisée. Les fonctions mathématiques
sinus, exponentielles et autres sont généralement implantées en utilisant les
développements en série entière. C'est-à-dire qu'on peut exprimer certaines
fonctions mathématiques sous forme de polynôme de degré N ; plus N sera élevé,
meilleure sera l'approximation. C'est bien souvent ce degré N qui sera notre
paramètre template, ainsi nous pourrons même contrôler à volonté la précision du
résultat. Une fois que vous aurez trouvé un bon compromis rapidité de compilation /
précision vous pourrez fixer N une bonne fois pour toute et éviter de le trimballer
dans tous vos appels de fonction.
De plus, ces polynômes approchants sont déterminés de manière itérative, donc
facilement de manière récursive, ce qui les rend assez adaptés à la meta-
programmation. Voici quelques exemples typiques de fonctions, une fois que vous
en aurez vu quelques uns et assimilé le processus, vous pourrez aisément écrire les
vôtres (pour peu que vous ayez la formule mathématique associée bien sûr).

La factorielle

template<unsigned int N> struct Factorielle

{
enum {Value = N * Factorielle<N - 1>::Value};
};
template<> struct Factorielle<0>
{
enum {Value = 1};
};
Attention, cette version est 100% calculée à la compilation, elle ne servira donc qu'à
calculer des constantes, et ne sera donc pas utilisée à l'exécution. Voici la même
mais en version "fonction inline", ce qui nous permettra de renvoyer un double et
donc de manipuler des nombres beaucoup plus grands (on est limité à 12! avec la
version ci-dessus)

template <int I> inline double Factorielle()

{
return I * Factorielle<I - 1>();
}
template <> inline double Factorielle<0>()
{
return 1.0;
}

La puissance

template <int N> inline double Puissance(double x)

{
return x * Puissance<N - 1>(x);
}
template <> inline double Puissance<0>(double x)
{
return 1.0;
}

L'exponentielle

// Ici N représente l'ordre, autrement dit la précision du calcul

template <int I> inline double Exp_(double x)

{
return Exp_<I - 1>(x) + Puissance<I>(x) / Factorielle<I>();
}
template <> inline double Exp_<0>(double x)
{
return 0.0;
}

template <int N> inline double Exponentielle(double x)

{
return x < 0.0 ? 1.0 / Exp_<N>(-x) : Exp_<N>(x);
}

Le cosinus

// Ici aussi, N resprésente l'ordre de développement

template <int N> inline double Cosinus(double x)

{
return Cosinus<N - 1>(x) + (N % 2 ? -1 : 1) * Puissance<2 * N>(x) / Factorielle<2 *
N>();
}
template <> inline double Cosinus<0>(double x)
{
return 1.0;
}
L'arctangente hyperbolique

template <int I> inline double Atanh(double x)

{
return Atanh<I - 1>(x) + Puissance<2 * I + 1>(x) / (2 * I + 1);
}
template <> inline double Atanh<1>(double x)
{
return x;
}
template <> inline double Atanh<0>(double x)
{
return 0.0;
}

III-A-3. Les conditions : spécialisation et opérateur