Discussion :

[Opérateur]

Bonjour,

J'ai une classe contenant certains opéateurs surchargés, que je dérive en une autre classe.
Seulement les opérateurs dans la classe dérivée ne fonctionnent pas comme ils devraient, alors qu'ils fonctionnent impeccablement dans la classe de base.
Auriez-vous une idéé sur l'origine du problème ?

Voici les détails :

Je définis dans ma classe de base les opérateurs que voici :

Code :

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

1
2
3
 
virtual Vecteur& operator + (Vecteur);
virtual Vecteur& operator = (const Vecteur&);

et cela fonctionne très bien.
Dans mon programme principal main je peux très bien écrire (pour des vecteurs v, w et z) :

Code :

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

1
2
3
 
v = w;
w = (z + v);

J'ai ensuite une classe polynôme, qui dérive (publiquement) de vecteur.
Je ne prends pas la peine de redéfinir les opérateurs en question vu que leur fonctionnement est en tout point identique.
Cependant pour trois polynômes a,b,c je peux écrire :

Code :

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

a = b;

mais si je tape :

Code :

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

a = (b + c);

le compilateur me dit qu'il ne trouve pas le code de la fonction = correspondante.
Cela me dépasse que cela fonctionne dans la classe de base mais pas dans la classe dérivée ...

merci

[Anthony.Desvernois]

Bonjour,

Peux tu donner le code de tes classes ?

[koala01]

Salut,

Déjà une question sans doute un peu bête, mais, pourquoi déclarer ces opérateurs virtuels, s'il ne faut pas les redéfinir dans les classes dérivées

Une autre question, sans doute tout aussi bête, mais, crois tu sincèrement réaliste de vouloir assigner un vecteur à... un complexe

Enfin, la dernière question qui fâche: es tu sûr de pouvoir dire que, d'un point de vue sémantique, un (nombre) complexe est un vecteur

La première réponse devrait t'inciter à supprimer le virtual de la déclaration des opérateurs pour ta classe vecteur.

La seconde devrait t'inciter à malgré tout redéfinir l'opérateur d'affectation (qui fait partie de ce que l'on appelle les "Big four") pour ta classe complexe, du moins, si le comportement par défaut ne correspond pas à tes attentes (ce qui est sans doute le cas), mais en admettant qu'il ne s'agit normalement pas d'un comportement polymorphe.

La troisième devrait t'inciter à réfléchir sur la réelle opportunité de déclarer un héritage

[Opérateur]

Désolé mais de quels complexes parles-tu ?
Il est question de polynôme de degré maximal N, qui sont vu comme des cas particuliers de vecteurs à N dimensions vu que la seule chose qu'un polynôme possède en plus est la possibilité de l'évaluer en un point x et de connaître son degré.

Ce n'est peut-être pas cohérent d'un point de vue orienté objet mais ça je n'y peux rien, c'est un projet que j'ai à faire pour un de mes cours et le professeur souhaite que ce soit fait ainsi

J'ai l'intention de dériver d'autres choses de cette classe, ce pourquoi les opérateurs sont virtuels.
Ici le comportement par défaut correspond à mes attentes justement, vu que additionner deux polynômes revient à additionner leurs coefficients qui sont les composantes d'un vecteur de R^N.

Sinon avez-vous besoin du code de toutes les classes en entier ?
Parceque c'est long et ça sera lourd si je copie colle tout ça ici.

Voici en tout le code de l'opérateur = :
(et oui petite précision ma classe vecteur est une classe template )

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
template <typename Elem, size_t DIM>
Vecteur<Elem,DIM>& Vecteur<Elem,DIM>::operator = (const Vecteur &V)
{
     if (&V != this)
     {
         for (size_t i = 0; i < DIM; i++)
            this->val_[i] = V.val_[i];
     }
     return *this;
}

Si vous voulez le reste du code je peux auss le mettre.

merci beaucoup.

[Twinside]

Code :

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

1
2
3
4
5
6
7
8
9
10
11
template <typename Elem, size_t DIM>
Vecteur<Elem,DIM>& Vecteur<Elem,DIM>::operator = (const Vecteur<Elem,Dim> &V)
{
     if (&V != this)
     {
         for (size_t i = 0; i < DIM; i++)
            this->val_[i] = V.val_[i];
     }
     return *this;
}

Peut-être qu'en respecifiant les param de template cela fonctionnera mieux (bon j'avoue, je ne suis pas sur)

[Opérateur]

Ah, il y a un problème avec les paramètres de template

merci

[koala01]

Désolé mais de quels complexes parles-tu ?
Il est question de polynôme de degré maximal N, qui sont vu comme des cas particuliers de vecteurs à N dimensions vu que la seule chose qu'un polynôme possède en plus est la possibilité de l'évaluer en un point x et de connaître son degré.

Au temps pour moi... j'avais bien lu polynôme, et ca s'est transformé - va savoir pourquoi - dans ma tête en "complexe"

Ce n'est peut-être pas cohérent d'un point de vue orienté objet mais ça je n'y peux rien, c'est un projet que j'ai à faire pour un de mes cours et le professeur souhaite que ce soit fait ainsi

Ah, ces profs qui n'arrivent pas à concevoir correctement l'orienté objet ()

J'ai l'intention de dériver d'autres choses de cette classe, ce pourquoi les opérateurs sont virtuels.
Ici le comportement par défaut correspond à mes attentes justement, vu que additionner deux polynômes revient à additionner leurs coefficients qui sont les composantes d'un vecteur de R^N.

Mais, le fait de vouloir (sans doute à juste titre, du moins, en partant du principe que ) dériver une classe pour laquelle tu définis n'importe quel opérateur (que ce soit l'opérateur d'assignation ou un autre) ne rend pas cet opérateur polymorphe pour autant...

Prenons l'exemple de l'opérateur d'assignation, car c'est celui dont on parle, mais le raisonnement est applicable à tous les autres...

Si tu as une classe de base nommée A et plusieurs (finalement pourquoi pas ) classe dérivées nommées B, C, D et E qui héritent de la classe de base:

• Tu vas souvent assigner un objet de type A à une variable type A
• Tu vas parfois assigner un objet de type B (ou C ou D ou E) à une variable de type A... mais comme l'objet de type B (ou C ou D ou E) peut passer pour un objet de type A, l'opérateur d'assignation de A suffit (de toutes manières, tu traitera ta variable comme s'il s'agissait d'un objet de type A, bien que tu fasse sans doute appel à des comportements polymorphes )
• Tu vas souvent assigner un objet de type B (ou C ou D ou E) à une autre variable de type B (ou respectivement C, D ou E), mais, à ce moment là, c'est l'opérateur (non polymorphe) de la classe en question qui est utilisé.
• Par contre, tu ne vas sans doute pas assigner un objet de type B à une variable de type C, D ou E, ou, si tu veux le faire, ce ne sera pas l'opérateur d'assignation qui devra être utilisé, mais un opérateur de conversion...

Tu te rend bien compte que les opérateurs n'ont finalement jamais aucune raison d'être polymorphe, même s'il peuvent appeler une fonction qui l'est, pour adapter un comportement attendu au type réellement utilisé

Dans la FAQ, tu trouve un exemple adapté à l'opérateur <<, mais le raisonnement est strictement identique

[Opérateur]

Ahhhh oui je crois que comprend maintenant

C'est évident, j'aurais dû y penser.
Mais donc, je vais devoir redéfinir tous mes opérateurs dans la classe dérivée ? Ca serait bête vu que le code est exactement pareiln il n'y a que la valeur de retour qui va changer ...

merci

[koala01]

Ahhhh oui je crois que comprend maintenant

C'est évident, j'aurais dû y penser.
Mais donc, je vais devoir redéfinir tous mes opérateurs dans la classe dérivée ? Ca serait bête vu que le code est exactement pareiln il n'y a que la valeur de retour qui va changer ...

merci

... Et le type de l'argument

En effet, il est peu probable que tu essaye d'assigner autre chose qu'un objet de type B (ou de type dérivé) à une variable de type B

Et donc, tu devra effectivement définir l'opérateur dans chaque classe qui en a besoin (si le comportement par défaut ne correspond pas pour le cas de l'opérateur d'assignation)

Mais cela implique que, si tu en viens à vouloir assigner autre chose qu'un objet de type B, il faut que tu prévoie la conversion

Peut être l'idiome copy and swap te sera-t-il utile

[Opérateur]

ah bon, ok.

Je crois que je comprend mieux à présent, merci beaucoup pour toutes les explications si détaillées, c'est vraiment gentil