Discussion :

[Hrayr]

Salut,
J’ai un problème avec héritage et operator*
J’ai un classe polynôme dynamique qui hérite de polynôme (abstrait) et
Un classe polynôme statique qui hérite de la même classe polynôme (abstrait) et une classe de Vector
Maintenant je dois pouvoir faire

Polynôme statique ps ;
ps*= ps ;
ps*= polynome dynamique ;
ps*= vector;
Combien operator* je dois avoir dans le classe polynôme statique ?
P.S. Quant je mes 2 operator un pour polynôme (abstrait) 2eme avec vector je n’arrive pas faire
ps*=ps ;

Merci d’avance pour votre aide

[koala01]

Salut, et bienvenue sur le forum

Sois déjà attentif au fait que ce n'est pas l'opérateur * que tu devrais surcharger, mais l'opérateur *= ...

En effet, si tu prend l'opérateur * dans son acception mathématique (qui est la multiplication), il renvoie normalement une nouvelle instance de ton polynome, et est à utiliser sous une forme proche de

Code :

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

1
2
3
Polynome p1(/*...*/);
Polynome p2(/*...*/);
Polynome resultat=p1*p2;

alors que l'opérateur *= va multiplier le polynome en cours avec l'argument qui lui est passé et renvoyer une référence sur... le polynome en cours (modifié).

Il sera donc utilisé sous la forme de

Code :

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

1
2
3
Polynome p1(/*...*/);
Polynome p2(/*...*/);
p1*=p2;

La différence est subtile mais tient au fait que, dans le premier cas, tu aura copie de l'argument en cours que tu n'aura pas forcément dans le second

Ceci dit, tu dois déclarer autant d'opérateurs différents que tu n'a de types potentiellement à droite de l'opérateur *=, mais, pour que tu puisse utiliser cet opérateur quel que soit le type de polynome utilisé (statique ou dynamique, même si je n'ai aucune idée de la différence que tu fait entre les deux), il faut que ces opérateurs soient déclarés dans la classe de base et appliquent ce que l'on appelle couramment l'idiome NVI (Non Virtual Interface), dont tu as un exemple à propos de l'opérateur << dans la FAQ

Cela prendrait donc la forme de

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
class Polynome
{
    private:
        /* pour la classe de base, nous ne pouvons pas déterminer le
         * comportement de multiplication...
         * nous déclarons donc des fonctions virtuelles pures (qui auront
         * pour effet de rendre la classe ininstanciable car abstraite)
         */
        virtual void multiply(Polynome const&) =0; // s'applique quand  l'opérande
                                                   //de droite est un polynome 
                                                   // (statique ou dynamique)
        virtual void multiply(Vector const &) = 0; // s'applique quand
                                                   // l'operande de droite est un 
                                                   // vector
    public:
        Polynome& operator*=(Polynome const & rhs)
        { 
            multiply(rhs);
            return *this;
        }
        Polynome& operator*=(Vector const & rhs)
        { 
            multiply(rhs);
            return *this;
        }
 
};
class PolynomeStatic :  public Polynome
{
    private:
        void multiply(Polynome const &); /* à implémenter dans le *.cpp */
        void multiply(Vector const &); /* idem */
        /* les membres intéressants */
};
class PolynomeDynamic:  public Polynome
{
    private:
        void multiply(Polynome const &); /* à implémenter dans le *.cpp */
        void multiply(Vector const &); /* idem */
        /* les membres intéressants */
};

[Hrayr]

Merci beaucoup

J'ai 2 operator*=
Donc quant je fait polynome statique *= polynome staitique il utilise le operator*= de polynome (abstrait) mais pas celu ci de especevec
pourquoi?

P.S.

Code :

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

1
2
3
4
5
6
7
8
9
10
class PolynomeS : public EspaceVec<Elem, N+1>, public Polynome<Elem> {
 
PolynomeS& operator= (const Polynome<Elem>&);
PolynomeS& operator= (const EspaceVec<Elem,N+1>& );
}
 
main()
 
PolynomeS<int, 5> polyS(2);
polyS*=polyS utilise (PolynomeS& operator= (const Polynome<Elem>&);)

mais pas PolynomeS& operator= (const EspaceVec<Elem,N+1>& );
pourquois?

[Luc Hermitte]

Injecter une sémantique de valeur dans une hiérarchie de classes polymorphes n'est jamais une partie de plaisir.
Je partirais définitivement sur du full-template au lieu de l'héritage.

[Hrayr]

le operator= dans mon classe polynome

Code :

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

1
2
3
4
5
6
template <typename Elem>
class Polynome {
 
Polynome& operator= (const Polynome&){};
Polynome& operator*= (const Polynome& p){};
};

dans le EspceVec

Code :

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

1
2
3
4
5
6
template <typename Elem, size_t N=10>
class EspaceVec : public VecS<Elem, N> {
 
EspaceVec& operator= (const EspaceVec&);
EspaceVec& operator*= (const EspaceVec& p);
}

dans mon classe Polnome statique

Code :

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

1
2
3
4
5
6
7
8
9
10
template <typename Elem, size_t N=10>
class PolynomeS : public EspaceVec<Elem, N+1>, public Polynome<Elem> {
 
PolynomeS& operator= (const Polynome<Elem>&);
PolynomeS& operator= (const EspaceVec<Elem,N+1>& );
 
PolynomeS& operator= (const Polynome<Elem>& p);
PolynomeS& operator= (const EspaceVec<Elem,N+1>& p);
 
};

mtn quant je vais polynome staique=polynome statique il utilise le 1ere operator= (celui de polynome).
Est-ce que c'est normal?
Si oui pourquois?

Encore un autre problem quant je veux utiliser operaror*= pour multiplier 2 polynomeS ca marche si les taille des polynomeS sont differents, sinon il affiche ambiguous averload for operator*= candidates sont les 2 que j'ai mis dans le polynomeS
Commant je peux resudre ce probleme?


Merci d'avance