4.10.2 La partie plus difficile

Précédent
La partie facile		Parent
Réécrivons tout cela un peu mieux		SommaireSuivant
Le fichier PBaseExpressionTemplateIterator.h complet

Enfin, plus difficile, c'est une façon de parler, car ce n'est pas si compliquer que cela. Il suffit de prendre les opérateurs qui dépendes de PVector et de remplacer PVector par une variable d'une fonction macro.

Il s'agit là d'une méthode bourrin, qui fonctionne très bien.

Nous obtenons une série de macros pour définir les différents opérateurs : 

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
 
/////////////////////////////////////////////////////////////////////////////////////////////////////
//                                                                                                 //
//   Macros qui définissent la surcharge des opérateurs pour un type quelconque et son itérateur   //
//                                                                                                 //
/////////////////////////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////
//                                //
//   Ce qui concerne l'addition   //
//                                //
////////////////////////////////////

//Macro qui permet de définir la surcharge de l'opérateur + à gauche pour un type définit, et son itérateur constant
/*	Le TYPE peut être : PVector
 * 	Le TYPECONSTITERATOR peut être : PVector::ConstIterator
*/
#define PSURCHAGE_IT_TYPE_OP_ADD_LEFT(TYPE,TYPECONSTITERATOR) template<class T> BinaryOp<TYPECONSTITERATOR, T, Add> operator +(const TYPE& v1, const T& v2){return MakeAdd(v1.begin(), v2);}

//Macro qui permet de définir la surcharge de l'opérateur + à droite pour un type définit, et son itérateur constant
/*	Le TYPE peut être : PVector
 * 	Le TYPECONSTITERATOR peut être : PVector::ConstIterator
*/
#define PSURCHAGE_IT_TYPE_OP_ADD_RIGHT(TYPE,TYPECONSTITERATOR) template <class T> BinaryOp<T, TYPECONSTITERATOR, Add> operator +(const T& v1, const TYPE& v2){return MakeAdd(v1, v2.begin());}

//Macro qui permet de définir la surcharge de l'opérateur + pour deux types définis, et leur itérateur constant
/*	Le TYPE peut être : PVector
 * 	Le TYPECONSTITERATOR peut être : PVector::ConstIterator
*/
#define PSURCHAGE_IT_TYPE_OP_ADD_TYPE(TYPE,TYPECONSTITERATOR) BinaryOp<TYPECONSTITERATOR, TYPECONSTITERATOR, Add> operator +(const TYPE& v1, const TYPE& v2){return MakeAdd(v1.begin(), v2.begin());}

/////////////////////////////////////////
//                                     //
//   Ce qui concerne la soustraction   //
//                                     //
/////////////////////////////////////////

//Macro qui permet de définir la surcharge de l'opérateur - pour deux types définis, et leur itérateur constant
/*	Le TYPE peut être : PVector
 * 	Le TYPECONSTITERATOR peut être : PVector::ConstIterator
*/
#define PSURCHAGE_IT_TYPE_OP_SUB_TYPE(TYPE,TYPECONSTITERATOR) BinaryOp<TYPECONSTITERATOR, TYPECONSTITERATOR, Sub> operator - (const TYPE& v1, const TYPE& v2){return MakeSub(v1.begin(), v2.begin());}

///////////////////////////////////////////
//                                       //
//   Ce qui concerne la multiplication   //
//                                       //
///////////////////////////////////////////

//Macro qui permet de définir la surcharge de l'opérateur * à gauche pour un type définit, et son itérateur constant
/*	Le TYPE peut être : PVector
 * 	Le TYPECONSTITERATOR peut être : PVector::ConstIterator
*/
#define PSURCHAGE_IT_TYPE_OP_MULT_LEFT(TYPE,TYPECONSTITERATOR) BinaryOp<TYPECONSTITERATOR, UnaryOp<double, Const>, Mult> operator * (const TYPE& v1, double d){return MakeMult(v1.begin(), MakeConst(d));}

//Macro qui permet de définir la surcharge de l'opérateur * à droite pour un type définit, et son itérateur constant
/*	Le TYPE peut être : PVector
 * 	Le TYPECONSTITERATOR peut être : PVector::ConstIterator
*/
#define PSURCHAGE_IT_TYPE_OP_MULT_RIGHT(TYPE,TYPECONSTITERATOR) BinaryOp<UnaryOp<double, Const>, TYPECONSTITERATOR, Mult> operator * (double d, const TYPE& v1){return MakeMult(MakeConst(d), v1.begin());}

//Macro qui permet de définir la surcharge de l'opérateur / à droite pour un scalaire (ici un double), et son itérateur constant
/*	Le TYPE peut être : PVector
 * 	Le TYPECONSTITERATOR peut être : PVector::ConstIterator
*/
#define PSURCHAGE_IT_TYPE_OP_DIV_SCAL(TYPE,TYPECONSTITERATOR) BinaryOp<TYPECONSTITERATOR, UnaryOp<double, Const>, Div> operator / (const TYPE& v1, double d){return MakeDiv(v1.begin(), MakeConst(d));}

//Macro qui permet de définir la surcharge de l'opérateur - (pour définir l'opposé d'un type), et son itérateur constant
/*	Le TYPE peut être : PVector
 * 	Le TYPECONSTITERATOR peut être : PVector::ConstIterator
*/
#define PSURCHAGE_IT_TYPE_OP_MINUS(TYPE,TYPECONSTITERATOR) UnaryOp<TYPECONSTITERATOR, Minus> operator - (const TYPE& v1){return MakeMinus(v1.begin());}

Et on peut même rajouter une autre macro pour appeler les autres : 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
////////////////////////////////////////////////////////////////////////////////////////////
//                                                                                        //
//   Et maintenant une grosse macro de fainéant qui permet de tout faire d'un seul coup   //
//                                                                                        //
////////////////////////////////////////////////////////////////////////////////////////////

//Macro qui permet de définir la surcharge de tout les opérateurs pour un type, et son itérateur constant
/*	Le TYPE peut être : PVector
 * 	Le TYPECONSTITERATOR peut être : PVector::ConstIterator
*/
#define PSURCHAGE_IT_TYPE_ALL_OP(TYPE,TYPECONSTITERATOR) PSURCHAGE_IT_TYPE_OP_ADD_LEFT(TYPE,TYPECONSTITERATOR) \
PSURCHAGE_IT_TYPE_OP_ADD_RIGHT(TYPE,TYPECONSTITERATOR) \
PSURCHAGE_IT_TYPE_OP_ADD_TYPE(TYPE,TYPECONSTITERATOR) \
PSURCHAGE_IT_TYPE_OP_SUB_TYPE(TYPE,TYPECONSTITERATOR) \
PSURCHAGE_IT_TYPE_OP_MULT_LEFT(TYPE,TYPECONSTITERATOR) \
PSURCHAGE_IT_TYPE_OP_MULT_RIGHT(TYPE,TYPECONSTITERATOR) \
PSURCHAGE_IT_TYPE_OP_DIV_SCAL(TYPE,TYPECONSTITERATOR) \
PSURCHAGE_IT_TYPE_OP_MINUS(TYPE,TYPECONSTITERATOR)

Et voilà.

Précédent
La partie facile		Parent
Réécrivons tout cela un peu mieux		SommaireSuivant
Le fichier PBaseExpressionTemplateIterator.h complet