Salut,
A mon sens, tu gagnera énormément en modularité et en souplesse avec les template, et principalement avec les traits de politiques et les politiques 
.
De plus, tu t'évitera sans doute bien des recopies manuelles de code, et tu limitera de ce fait les risques d'erreur
En effet, l'utilisation des directives préprocesseurs devrait être, à mon sens, limitée à quelques points particuliers:- l'inclusion des fichiers d'en-tête ( directive #include )
- les garde anti inclusion (directives #ifndef MACHINCHOSE_H #define #endif) qui entourent le contenu de l'en-tête
- Le choix de l'exportation ou non et de l'importation ou non (lorsque l'on envisage de créer éventuellement une dll)
- Quelques cas permettant de simplifier l'écriture
Le dernier point serait celui qui permettrait de remplacer un code proche de
typedef TypeList<int,<TypeList<char,TypeList<double,NullType> > > malist;
en quelque chose proche de
typedef TYPELIST_3(int, char, double) malist;
(exemple personnel basé sur la bibliothèque Loki)
En effet, imagine, simplement, que tu doive avoir recours dans un code à deux options a priori incompatibles entre elles...
Si tu décide d'utiliser les directives préprocesseurs, tu devra, dans le meilleur des cas, créer deux fichiers d'implémentation, dans le pire, veiller à "dé définir" chaque symbole défini et à "ré-inclure" le fichier d'en-tête. avant de recopier quasi mot à mot le code dont tu as besoin, sous une forme proche de
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
| #define VALEUR1 true
#define VALEUR2 false
/*...
* Macros.h se base sur la définition de VALEUR1 et de VALEUR2
* pour définir d'autres macros ;)
*/
#include "Macros.h"
/* le code adapté à VALEUR1 et VALEUR2
* et utilisant ce qui est défini dans Macros.h
*/
#undef VALEUR1
#undef VALEUR2
/* pour permettre la ré inclusion de Macros.h
*/
#undef MACROS_H
/* il ne faudrait pas oublier de dé définir les différentes
* marcros en question
* ...
*/
/* changeons les valeurs */
#define VALEUR1 false
#define VALEUR2 true
/* ré inclusion de macros.h */
#include "macros.h"
/*et continuons notre code */ |
Alors que si tu utilises correctement les traits de politiques et les politiques, tu peux en arriver à quelque chose proche de
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
| struct Politique1_vrai
{
void doSomething(){/*...*/}
};
struct Politique1_faux
{
void doSomething(){/*...*/}
};
struct Politique2_vrai
{
void doOtherThing(){/*...*/}
};
struct Politique2_faux
{
void doOtherThing(){/*...*/}
};
template <class Pol1, class Pol2>
class Work:public Pol1, public Pol2
{
private:
/* quelques données intéressantes */
};
/* Dans l'implémentation:
* Je veux utiliser Politique1_vrai et politique2_vrai...
*/
typedef Work<Politique1_vrai,politique2_vrai> WorkVraiVrai;
WorkVraiVrai wvv;
wvv.doSomenthing();
wvv.doOtherThing();
/* Je veux utiliser il existe 4 possibilités différentes, et nous pouvons
* chaque fois créer un type qui correspond par simple typedef (pour la
* facilité d'écriture ;)) sans avoir à réécrire une ligne de code
* supplémentaire
*
* Le mieux de tout, c'est que nous n'aurons pas de problème
* avec les différentes options incompatibles
*/ |
[Templates] templates vs. directives de préprocesseurs
Répondre avec citation
A méditer: La solution la plus simple est toujours la moins compliquée
Envoyé par Nanoc
Partager