Discussion :

[koala01]

Ca, c'est un point de vue tout à fait intéressant, tiens ! En effet, peut-être devrais-je définir une classe (disons, abstraite) Matrice_A, que je dériverai en "Matrice_Normale" et "Matrice_homogene".
Ca éviterait les bidouilles de const, mais en complexifiant pas mal le design (tous les opérateurs à redéfinir dans les 2 classes, avec dans la version homogène, l'appel à la normalisation).

Bon après, je ne cache pas que mon design était surtout orienté sur le "faut'kça'marche!", en utilisant l'idiome de programmation "quick and dirty"...

Je me couche moins bête ce soir, merci Developpez!

Pas *forcément*...

Quel que soit l'opérateur que tu définis, il a un comportement strictement identique dans une matrice homogène et dans une matrice normale...

La seule différence tient dans le fait que, après ce comportement, tu demande à une matrice homogène de faire "quelque chose de plus": la normalisation.

Tu peux donc définir, en tant que fonction virutelle réelle, le comportement (à l'exception de la normalisation) de la fonction dans la classe de base: ce comportement étant le "minimum commun".

Dans la classe matrice homogène (uniquement), tu spécialise ce comportement en

1. appelant le comportement de base (Base::comportement(/*argument éventuels */ )
2. appelant le comportement de normalisation (normalize(); )

Et, tant qu'à faire, tu rajoute un constructeur dans ta classe représentant ta matrice homogène prenant une matrice normale sous la forme d'une référence constante et... appelant cette fonction normalize().

Le but de ce constructeur étant de servir d'opérateur de conversion implicite entre une matrice "normale" et une matrice homogène

Au final cela donnerait quelque chose comme

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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();
}

Le constructeur de matrice homogène que je te propose de rajouter te permettrait, avec une fonction proche de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
void doSomething(MatriceHomogene const & mh)
{
    /*...*/
}

de l'appeler sous une forme proche de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
MatriceNormale mn(/* arguments éventuels */);
/*...*/
doSomething(mn); /* provoque la création d'une variable temporaire 
                  * non nommée spécialement pour la fonction
                  */