Polymorphisme récursif avec héritage

Version imprimable

Bonjour à tous,

Tout d'abord, désolé pour le titre mais je ne savais pas trop quoi mettre...

Je suis en train de me programmer une classe pour m'aider dans mes développements. Le but de cette classe est de fournir les opérateurs d'égalité et de comparaison (comme std::rel_ops).
Mais voilà, j'ai un problème...

Code:

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
#include <iostream>
#include <string>
 
using namespace std;
 
namespace
{
    class Operator
    {
        public:
            virtual ~Operator() throw() {}
            virtual bool operator == (const Operator &op) const throw()
            {
                cout << "Operator ==" << endl;
                return !(*this != op);
            }
            virtual bool operator != (const Operator &op) const throw()
            {
                cout << "Operator !=" << endl;
                return !(*this == op);
            }
            virtual void fct1(const Operator &op) const throw()
            {
                cout << fct2() << endl;
                cout << op.fct2() << endl;
            }
            virtual string fct2() const throw()
            {
                return "Operator fct2()";
            }
    };
 
    class Test : public Operator
    {
        int _nb;
        public:
            Test(int n) : _nb(n) {}
            virtual ~Test() throw() {}
            virtual bool operator == (const Test &op) const throw()
            {
                cout << "Test ==" << endl;
                return _nb == op._nb;
            }
            virtual string fct2() const throw()
            {
                return "Test fct2()";
            }
    };
}
 
int main(int argc, char *argv[])
{
    Test t1(3), t2(5);
    t1.fct1(t2);  // {1}
 
    if (t1 == t2) // {1}
        cout << "t1 == t2" << endl;
    else if (t1 != t2)  // {2}
        cout << "t1 != t2" << endl;
 
    return 0;
}

{1} : ici la fonction va faire un appel à Operator::fct1() qui elle même fait appel à Test::fct2(). Tout fonctionne correctement.
{2} : j'appelle directement la fonction Test::operator==(), donc ok ça fonctionne.
{3} : ...et c'est ici que je plante : le premier appel utilise Operator::operator!=(), par contre celle-ci fait appel à Operator::operator==() à la place de Test::operator==().

Est-ce que je me suis planté quelque part ? Vu que les fonctions fct1/fct2 marchent bien...

Merci pour votre aide,

Tipoun

02/04/2008, 21h07
Luc Hermitte

Citation:

Envoyé par Tipoun

Est-ce que je me suis planté quelque part ?

En voulant mélanger héritage et sémantique de valeur...
Tu peux persister dans cette voie, mais si tu arrives à quelque chose, cela sera d'une complexité des plus inutiles.

Que veux-tu vraiment faire ? Pourquoi l'héritage?
02/04/2008, 21h18
Tipoun

Citation:

Envoyé par Luc Hermitte

En voulant mélanger héritage et sémantique de valeur...
Tu peux persister dans cette voie, mais si tu arrives à quelque chose, cela sera d'une complexité des plus inutiles.

Que veux-tu vraiment faire ? Pourquoi l'héritage?

Arff.... :(

À la base je voulais utiliser les surcharges automatiques des opérateurs définies dans <utility>.
Il suffit de définir les opérateurs == et < pour avoir !=, <=, > et >=.
Cependant, cela m'oblige à déclarer "using std::rel_ops" dans chaque fichier de classe utilisant ces opérateurs.
J'ai alors pensé à faire une classe pour faciliter la déclaration. Donc dans la classe fille, je n'ai plus qu'à créer les fonctions == et < (comme avec l'utilisation de std::rel_ops, mais sans les "using").

C'est assez clair ? :oops:
02/04/2008, 21h37
Luc Hermitte

OK je vois. Il me semble avoir vu des trucs à ce sujet dans boost.

D'ailleurs, est-ce que cette discussion pourrait t'aider : http://lists.boost.org/Archives/boos.../07/107856.php ?
02/04/2008, 22h47
Tipoun

Merci pour ce lien, c'est exactement ce que je cherchais ^^ :king:

Bonjour,
pour en revenir à ton exemple de départ, je viens de comprendre pourquoi le cas {3} ne te donne pas le résultat que tu attendais. En fait la méthode bool operator == (const Operator &op) n'est jamais redéfinie dans Test ! La méthode bool operator == (const Test &op) n'ayant pas les mêmes paramètres, il s'agit d'une nouvelle méthode virtuelle indépendante de l'autre. Avec fct1 et fct2 cela reviendrait à
Code:

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 class Operator { public: virtual void fct1(const Operator &op) const throw() { cout << "Operator fct1()" << endl; fct2(op); } virtual void fct2(const Operator &op) const throw() { cout << "Operator fct2()" << endl; } }; class Test : public Operator { int _nb; public: Test(int n) : _nb(n) {} virtual ~Test() throw() {} virtual void fct2(const Test &op) const throw() { cout << "Test fct2()" << endl; } }; int main(int argc, char *argv[]) { Test t1(3), t2(5); t1.fct1(t2); // {1} return 0; }
Produit :

Citation:

Operator fct1()
Operator fct2()

03/04/2008, 20h46
Tipoun

Effectivement, la surcharge ne marche que pour les types identiques et non pas pour les héritages...
Merci pour cette précision :king: