Discussion :

[sgu35]

Bonjour,

j'ai une classe permettant de gérer des fractions (appelée ZFraction) et j'ai du mal à comprendre la définition de l'opérateur moins unaire ci-dessous:

Code :

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

1
2
3
4
5
6
7
 
ZFraction operator-(ZFraction const& a)
{
    ZFraction copie(a);
    copie*=-1; // ici je ne comprends pas 
    return copie;
}

Auparavant on a défini l'opérateur *= , méthode de la classe ZFraction, comme ceci :

Code :

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

1
2
3
4
5
6
7
8
9
 
ZFraction& ZFraction::operator*=(const ZFraction& a)
{
    m_num*=a.m_num;
    m_den*=a.m_den;
    reduire();
 
    return *this;
}

Ce qui voudrait dire que -1 est considéré comme fraction?

Merci pour vos éclaircissements.

[therwald]

bonjour,
il est possible qu'on ait défini une conversion des entiers vers les fractions (ce qui se fait en définissant un constructeur de fraction prenant un entier en argument). Ça ne paraît pas absurde à priori, puisque on peut exprimer un entier n par n'import quelle fraction telle que num=denom*n.

[Bousk]

Ou alors tu as une autre surcharge de l'operator*= qui prend un entier.

[sgu35]

Bonjour Therwald, je ne comprends pas ce que tu as écrit :

on peut exprimer un entier n par n'import quelle fraction telle que num=denom*n.

à mon avis si n est un entier, sa conversion en fraction est telle que son numérateur vaut n et son dénominateur vaut 1.

Bonjour Bousk, tu as écrit :

Ou alors tu as une autre surcharge de l'operator*= qui prend un entier.

Je n'ai que l'opérateur*= dont l'ai donné la définition au premier message.

Par contre, j'ai un constructeur 3 en 1 défini comme ci-dessous :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
ZFraction::ZFraction(int num,int den):m_num(num),m_den(den)
{
    if (m_den==0)
    {
        std::cout<<"Erreur : division par 0"<<std::endl;
        exit(EXIT_FAILURE);
    }
 
    signe();//Méthode interne de la classe ZFraction pour ramener le signe au numérateur
    reduire();//Méthode interne de la classe ZFraction pour rendre une fraction irréductible
 
 
}

Ce constructeur peut prendre soit 0, soit 1, soit 2 arguments.
D'ailleurs si j'écrit copie*=ZFraction() ou copie*=ZFraction(1), ou ZFraction(1,2), il construit la ZFraction et effectue le calcul en conséquence.

[therwald]

Bonjour Therwald, je ne comprends pas ce que tu as écrit :

on peut exprimer un entier n par n'import quelle fraction telle que num=denom*n.

1) n/1 est une fraction, car personne n'a dit que le dénominateur 1 est interdit.
2) n/1 est la fraction réduite, mais 2n/2 est tout aussi valide...
Mon propos, c'est que comme tout an/a avec a!=0 est une fraction valide qui a la même valeur que l'entier n, alors la conversion de tout entier n en une fraction de la forme an/a est valide et permet de construire une fraction à partir de n et faire des opérations avec.
Donc c'est sémantiquement valable, et techniquement s'il existe un constructeur de ta classe de fraction qui peut accepter un entier unique en entrée il sera automatiquement appliqué pour faire la conversion, sauf si tu as refusé cette conversion en appliquant le mot-clef explicit au constructeur.
la définition de constructeur que tu montres ne permet pas de savoir si le constructeur acceptera un entier unique en argument, je suppose que la déclaration est du style:

Code :

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

ZFraction::ZFraction(int num=0,int den=1);