Discussion :

[raf_gug]

Salut à tous!
Je cherche à surcharger l'opérateur unaire - dans un cadre d'héritage. Je voudrais faire quelque chose comme cela:

Code :

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

1
2
3
4
5
6
7
8
9
class Number_template
{
virtual Number_template operator-( );
};
 
class Number : public Number_template
{
Number operator-( );
};

Apparemment, pour que cela fonctionne, je devrais retourner non pas un Number mais un pointeur vers un Number. Mais je ne vois pas trop comment faire.

Quelqu'un à une idée?

Merci!

Rafael

[mitkl]

un peu de cette manière : http://cpp.developpez.com/faq/cpp/?p...URCHARGE_pp_mm

[raf_gug]

Merci pour ta réponse.

J'y ai pensé mais ce qui change fondamentalement (je pense, mais peut être que je passe à côté de quelque chose), c'est que mon opérateur unaire ne modifie pas l'objet, donc je peux pas retourner *this. Du coup, je vois pas trop sur quoi retourner un pointeur...

[valAa]

Pourquoi devrais-tu retourner un pointeur ?
Habituellement l'opérateur unaire de négation renvoie par copie un nouvel objet.

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
 
#include <iostream>
 
class A
{
    int m_x;
 
public:
 
    A(int x)
    {
        m_x = x;
    }
 
    int getx() const
    {
        return m_x;
    }
 
    A operator-() const
    {
        return A(-m_x);
    }
 
};
 
int main(int argc, char **argv)
{
    A a(3);
    std::cout << "a.getx() : " << a.getx() << std::endl;
    std::cout << "-a.getx() : " << (-a).getx() << std::endl;
    return 0;
}

compile et donne à l'exécution :

Code :

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

1
2
a.getx() : 3
-a.getx() : -3

[raf_gug]

valAa: car je fais de l'héritage. J'ai l'impression que sinon cela ne fonctionne pas (car les méthodes n'ont plus la même signature).

[Neckara]

Ceci devrait marcher :

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
 
//soit A la classe mère.
 
//dans A :
virtual const A operator-(const A & a) const
    {
        /* tu définis un constructeur qui prenne en paramètre un const A & et un const A &
qui construise ton objet comme tu le souhaites. */
        return A(*this, a);
    }
 
//dans la classe fille :
 const [Type Classe Fille] operator-(const A & a) const
    {
        /* tu définis un constructeur qui prenne en paramètre un const [Type Classe Fille] & et un const A &
qui construise ton objet comme tu le souhaites. */
        return [Type Classe Fille](*this, a);
    }
 
OU
 
//dans A :
virtual const A operator-() const
    {
        /* tu définis le constructeur selon ce qui t'arrange */
        return A(...);
    }
 
//dans la classe fille :
 const [Type Classe Fille] operator-() const
    {
        /*tu définis le constructeur selon ce qui t'arrange */
        return [Type Classe Fille](...);
    }

renvoyer une copie ne marcherais pas puisque si on retournerais à chaque fois une instance de la classe mère et non une instance de la classe fille.

EDIT : le type de retour n'est pas pris en compte lors de la résolution du compilateur.