Discussion :

[Invité]

Bonsoir,
Je me penche sur une question à laquelle je narrive pas à trouver de réponse dans les différents cours/FAQ sur le net.
j'ai une classe abstraite A et sa dérrivée B:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
class A
{
 public:
  A& add(const A&) =0;
};
 
class B: public A
{
 public:
  B& add(const A&);
};

A priori B::add n'a pas la même signature que A::add, donc pas de raison pour que le compilateur me l'accepte comme surcharge de A::add. Yatil donc un moyen pour que le compilateur me l'accepte quandmeme?

Accepteratil B& add(const B&); ?

Les exemples sur le net sont tous des fonctions void fonction(); donc là pas de problème.

Dans mon cas, il s'agit de surcharger l'opérateur += et -= d'une classe

[JolyLoic]

Le type de retour est différent, mais pas tant que ça... Tu es dans un cas qu'on appelle "covariant return type", et donc tu as bien redéfini la fonction de la classe de base (certains compilateurs ont un peu de mal avec cette règle).

[koala01]

Salut,

Ce qu'il faudrait surtout, c'est déclarer A::add comme étant une fonction virtuelle (car, en effet, le seul " = 0" à la fin de la déclaration ne suffit pas pour rendre une fonction "virtuelle pure" )

Une fois cette précaution prise, tu pourra utiliser le retour covariant avec beaucoup plus de facilités

Fait cependant attention au fait que les opérateurs ne peuvent pas être virtuels... (et ne peuvent donc a fortiori pas être virtuels purs)

Il est donc utile de se poser en priorité la question si les opérateur += et -= seront généralement utilisés dans un cadre polymorphe (où tes classes dérivées se font généralement passer pour des classes de bases) ou non.

Si c'est le cas, il faudra utiliser l'idiome que l'on appelle NVI (Non Virtual Interface, ou, si tu préfères en francais Interface non virtuelle), qui serait proche, dans ton cas, 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
class A
{
    public:
        A& operator+=()(A const & a)
        {
            return add(a);
        }
        A& operator-=()(A const & a)
        {
             return substract(a);
        }
    private: 
        /* les fonctions sont déclarées en privées, car cela passe 
         * bien avec le NVI, à toi de voir si tu veux les exposer ou non
         * (mais c'est a priori inutile ;))
         */
        virtual A& add(A const & ) = 0;
        virtual A& add(A const & ) = 0;
};
class B : public A
{
    private: 
        /* les fonctions sont déclarées en privées, car cela passe 
         * bien avec le NVI, à toi de voir si tu veux les exposer ou non
         * (mais c'est a priori inutile ;))
         *
         * veille juste à ne pas les exposer si tu les laisse privées dans A ;)
         * 
         * Elles doivent être implémentées pour que B puisse devenir une
         * classe concrète ;)
         */
        virtual B& add(A const & );
        virtual B& add(A const & );
 
};

[Invité]

oh cool, merci
ça met un nom sur ce que je cherchait: covarient return types
En effet la solution sera d'implémenter une non virtual interface.
Bonne soirée