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
| class MatriceBase
{
public:
/* tu place les constructeurs qui t'intétressent :D */
void foo() const;
virtual void bar();
virtual ~MatriceBase() = 0; /* pour empêcher la création d'une instance */
}
MatriceBase::~MatriceBase()
{
/* Cela peut surprendre de voir la définition d'une fonction virtuelle pure,
* mais elle a pour objectif de permettre le comportement polymorphe
* au moment de la destruction ;)
*/
}
void MatriceBase::foo() const
{
/* La matrice n'est pas modifiée, ni de manière logique ni de manière
* mathématique...
*
* il n'y a donc aucune raison de redéfinir la fonction pour la matrice
* homogène :D
*/
}
void MatriceBase::bar()
{
/* Cette fonction modifie, au minimum du point de vue logique,
* la matrice...
*
* Si elle est appelée sur une matrice homogène, elle devra être suivie
* d'un appel à normalize()
*/
}
class MatriceNormale : public MatriceBase
{
/*il n'y a aucune fonction à redéfinir ici... cette classe ne fait que
* réaliser la classe de base
*
* (pense quand même à créer les constructeurs ad-hoc ;))
*/
};
class MatriceHomogene : public MatriceBase
{
public:
/* tu rajoutes les constructeurs "qui vont bien", et on en ajoute un
* qui servira d'opérateur de conversion implicite
*/
MatriceHomogene(MatriceNormale const & n):
MatriceBase(/*parametres adéquats basé sur n */)
{
normalize();
}
/* redéfinition de la fonction bar()... */
virtual void bar();
private:
normalize()
{
/* ce qu'il faut faire pour normaliser ta matrice */
}
}
void MatriceHomogene::bar()
{
/* appelons le comportement de base */
MatriceBase::bar();
/* et la normalisation */
normalize();
} |
