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
| #include <iostream>
#include <vector>
// Politique qui vérifie que les éléments Hr et Mn sont compris entre 0 et 59.
struct PolicyCheck
{
static std::pair<int, int> Check(std::pair<int, int> HrMn)
{
if(HrMn.first < 0)
HrMn.first=0;
else if(HrMn.first > 59)
HrMn.first=59;
if(HrMn.second < 0)
HrMn.second=0;
else if(HrMn.second > 59)
HrMn.second=59;
}
};
// Politique qui ne vérifie rien.
struct PolicyNoCheck
{
static std::pair<int, int> Check(std::pair<int, int> HrMn)
{
return HrMn;
}
};
// Déclaration d’une fonction paramétrée par les politiques.
template<typnename _CheckPolicy>
std::pair<int, int> MakeTimePair(int Hr, int Mn); // déclaration légale.
// Classe encapsulant le concept d’heure.
// Ne gère que les heures et les minutes.
// Très incomplète, c’est juste pour l’exemple.
class TTime
{
public:
TTime();
// déclaration d’un constructeur paramétré par les politiques.
template<typename _CheckPolicy>
TTime(int Hr, int Mn); // déclaration légale !
// Je mets les données membres en public, je sais que c’est une grossière
// erreur de conception, mais c’est pour simplifier le code de l’exemple.
int Hr_;
int Mn_;
};
TTime::TTime()
: Hr_(),
Mn_()
{
}
// Définition de la fonction paramétrée par les politiques.
template<typename _CheckPolicy>
std::pair<int, int> MakeTimePair(int Hr, int Mn) // Définition légale.
{
return _CheckPolicy::Check(std::make_pair(Hr, Mn));
}
// Définition du constructeur paramétré par les politiques.
template<typename _CheckPolicy>
TTime::TTime(int Hr, int Mn) // Définition légale !
{
std::pair<int, int> Pair(_CheckPolicy::Check(std::make_pair(Hr, Mn)));
Hr_=Pair.first;
Mn_=Pair.second;
}
// Instanciations explicites de la fonction paramétrée par les politiques.
template
std::pair<int, int> MakeTimePair<PolicyCheck>(int Hr, int Mn);
template
std::pair<int, int> MakeTimePair<PolicyNoCheck(int Hr, int Mn);
// Instanciations explicites légales.
// Instanciations explicites du constructeur paramétré par les politiques.
template
TTime::TTime<PolicyCheck>(int Hr, int Mn);
template
TTime::TTime<PolicyNoCheck>(int Hr, int Mn);
// Instanciations explicites légales !
// Utilisation.
int main()
{
// Utilisation de la fonction paramétrée par les politiques.
std::vector<std::pair<int, int> > VectorPair;
VectorPair.push_back(MakeTimePair<PolicyCheck>(75, 75));
VectorPair.push_back(MakeTimePair<PolicyNoCheck>(75, 75));
std::cout << VectorPair[0].first << ':' << VectorPair[0].second << '\n';
std::cout << VectorPair[1].first << ':' << VectorPair[1].second << '\n';
// Utilisation légale.
// Utilisation du constructeur paramétré par les politiques.
std::vector<TTime> VectorTime; // Nécessite que les TTime soient tous du
// même type.
VectorTime.push_back(TTime<PolicyCheck>(75, 75)); // Illégal.
VectorTime.push_back(TTime<PolicyNoCheck>(75, 75)); // Illégal.
std::cout << VectorTime[0].Hr_ << ':' << VectorTime[0].Mn_ << '\n';
std::cout << VectorTime[1].Hr_ << ':' << VectorTime[1].Mn_ << '\n';
// Utilisation illégale ? Ou je ne connais pas la syntaxe d’appel ?
return 0;
} |
