surcharge de fonction

Version imprimable

bonsoir svp j'ai besoin d'explication. faites le le plus simplement du monde car
j'ai besoin de comprendre. merci les differentes questions se trouvent dans le code

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
 
Duree Duree::operator+(const Duree &duree)
{
    int heures = m_heures;
    int minutes = m_minutes;
    int secondes = m_secondes;
//premiere question
//pourquoi ne met on pas 
// secondes += duree2.m_seconde ?
 
//deuxieme question 
//ausii je vois que secondes represente represente les secondes de la duree1 
//mais je comprend pas comment car pour acceder à un element on doit 
//faire objet.attribut ou objet .methode donc comment accede t-on 
//a la valeur de duree1 et duree2?      
 
       secondes += duree.m_secondes; 
       minutes += secondes / 60;
       secondes %= 60;
 
 
    minutes += duree.m_minutes;
 
    heures += minutes / 60;
    minutes %= 60;
 
 
    heures += duree.m_heures;
 
//enfin cette ligne je ne la comprend pas du tout 
 
    // Création de l'objet resultat et retour
    Duree resultat(heures, minutes, secondes);
    return resultat;
}

08/10/2008, 23h14
Médinoc
1. Ben c'est ce qu'on fait, non?
2. Il n'y a pas de duree1 et duree2 ici: Il n'y a que this (pointeur) et duree (référence)
3. On crée un objet de type Duree en appelant son constructeur pour y mettre les valeurs de retour. Puis on retourne cet objet.
PS: Attention à ne pas confondre operator+ et operator+=...
09/10/2008, 00h47
newk++

surcharge de l'operateur+

merci medinoc mais j'avoue que ne comprend pas toujours j'ai besoin d'un peu d'explication car beaucoup de choses sont floues dans ma tete.
l
09/10/2008, 01h02
Nogane
Bonsoir,
Je vais tenter de t'aider, mais si tu ne comprend pas, pense à aller voir dans un vrai cour de C++ ;)

Citation:

//pourquoi ne met on pas
// secondes += duree2.m_seconde ?

La variable "secondes" est un int qui vient juste d'être construit, il faut donc d'abord l'initialiser, avant de lui ajouter duree.m_secondes
C'est ce que fait le code:
Code:

1 2 int secondes = m_secondes; secondes += duree.m_secondes;
Citation:

//ausii je vois que secondes represente represente les secondes de la duree1
//mais je comprend pas comment car pour acceder à un element on doit
//faire objet.attribut ou objet .methode donc comment accede t-on
//a la valeur de duree1 et duree2?

Celui que tu appel "duree1" s'appel ici "this" car tu est "dedans" (il y a surement un terme technique pour dire ça...).
Tu peut donc y accéder en faisant: this->m_secondes (car this est un pointeur)
Mais comme Mr C++ est gentil (il y a surement aussi un terme technique pour dire ça :P ), tu peu aussi écrire m_secondes directement.
Ce qui donne par exemple:

Code:

int secondes = m_secondes;

Citation:

//enfin cette ligne je ne la comprend pas du tout

Je supose que tu parle de ca:

Code:

Duree resultat(heures, minutes, secondes);

Il faut bien comprendre, comme le dit Médinoc, que ton opérateur est un "+", et pas un "+=", c'est a dire qu'il va faire l'addition est te renvoyer un NOUVEAU objet contenant le résultat, SANS MODIFIER tes deux durées.
Cette ligne déclare donc un NOUVEAU objet de type Duree, avec les valeur qui vienne d'être calculer, pour pouvoir le renvoyer..

surcharge de l'operateur+

bonsoir et merci pour les details de la reponse.Cependant j'ai toujours faim.
les cours je les ai lu et relu.
je vais reformuler ma question .
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 Duree Duree::operator+(const Duree &duree) { int heures = m_heures; int minutes = m_minutes; int secondes = m_secondes; secondes += duree.m_secondes; minutes += secondes / 60; secondes %= 60; minutes += duree.m_minutes; heures += minutes / 60; minutes %= 60; heures += duree.m_heures; //enfin cette ligne je ne la comprend pas du tout // Création de l'objet resultat et retour Duree resultat(heures, minutes, secondes); return resultat; }
1:on considere par exemple
Duree duree1(01,24,32) , duree2(3,45,23).
pour ce qui est de duree1() est ce parce qu'il est en premiere position que je suis dedans ? selon ce que tu as dis

Citation:

Celui que tu appel "duree1" s'appel ici "this" car tu est "dedans" (il y a surement un terme technique pour dire ça...).
Tu peut donc y accéder en faisant: this->m_secondes (car this est un pointeur)

2: dans le prototype de la fonction &duree est mis pour duree1 ou duree2 ?

si dans le code je met
secondes += duree.m_secondes est ce different de
secondes += duree2.m_secondes

merci de repondre à mes questions

09/10/2008, 03h57
loufoque

Ton code n'est pas const-correct.
Remplace

Citation:

Duree Duree::operator+(const Duree &duree)

par

Code:

Duree Duree::operator+(const Duree &duree) const

Sinon à part ça, ça aurait sûrement été plus intéressant d'implémenter operator+ à partir de operator+=.

Citation:

Envoyé par loufoque

Sinon à part ça, ça aurait sûrement été plus intéressant d'implémenter operator+ à partir de operator+=.

Je plussoie, et j'en fait la démonstration:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 Duree& Duree::operator+=(const Duree& duree) { m_secondes += duree.m_secondes; m_minutes += m_secondes / 60; m_secondes %= 60; m_minutes += duree.m_minutes; m_heures += m_minutes / 60; m_minutes %= 60; m_heures += duree.m_heures; return *this; } Duree Duree::operator+(const Duree& duree) const { Duree resultat(*this); resultat += duree; return resultat; }
Et à part ça, généralement, on implémente l'opérateur + en tant que fonction libre, plutôt qu'en tant que fonction membre.

Citation:
Envoyé par newk++
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 Duree Duree::operator+(const Duree &duree) { int heures = m_heures; int minutes = m_minutes; int secondes = m_secondes; secondes += duree.m_secondes; minutes += secondes / 60; secondes %= 60; minutes += duree.m_minutes; heures += minutes / 60; minutes %= 60; heures += duree.m_heures; //enfin cette ligne je ne la comprend pas du tout // Création de l'objet resultat et retour Duree resultat(heures, minutes, secondes); return resultat; }
Puis son utilisation
Code:

1 2 3 4 Duree duree1(01,24,32) , duree2(3,45,23); Duree resultat; resultat = duree1 + duree2;
Citation:

Envoyé par newk++

1:on considere par exemple
Duree duree1(01,24,32) , duree2(3,45,23).
pour ce qui est de duree1() est ce parce qu'il est en premiere position que je suis dedans ? selon ce que tu as dis

L'écriture duree1 + duree2 est équivalente à duree1.operator+(duree2). Donc, cela signifie que la méthode operator+ est appelée sur duree1 avec comme paramètre duree2. duree1 sera donc this (ou implicite) et duree2 sera le paramètre duree.

Citation:

Envoyé par newk++

2: dans le prototype de la fonction &duree est mis pour duree1 ou duree2 ?

Souviens-toi que duree1+duree2 est équivalent à duree1.operator+(duree2). Donc, this correspondra à duree1 et duree correspondra à duree2.

Citation:

Envoyé par newk++

si dans le code je met
secondes += duree.m_secondes est ce different de
secondes += duree2.m_secondes

Oui. Le second cas ne va pas compiler! Il faut comprendre le mécanisme de portée des variables:
Code:

1 2 3 4 5 6 7 int main() { duree duree1(12,36,45); duree duree2(4,17,23); duree resultat = duree1 + duree2; }
duree1 et duree2 ne sont connus comme symboles que dans main().
Dans Duree Duree::operator+(const Duree &duree), les variables connues sont this et duree. Lorsque tu fais l'appel duree1 + duree2, le compilateur se charge de faire correspondre this<->duree1 et duree<->duree2 (mécanisme de passage des paramètres).
D'ailleurs, comment ferais-tu pour
Code:

1 2 3 4 5 6 7 8 9 10 int main() { duree duree1(12,36,45); duree duree2(4,17,23); duree resultat = duree1 + duree2; duree duree3(1,7,12); duree duree4(0,08,3); resultat = duree3 + duree4; }
Enfin, Medinoc et loufoque te donne les bonnes pratiques dans ce genre de choses (const et affectation):

Code:

Duree Duree::operator+(const Duree& duree /* car duree ne sera pas modifié*/) const /* car this ne sera pas modifié*/

et
Code:

1 2 3 4 5 6 Duree Duree::operator+(const Duree& duree) const { Duree resultat(*this);// on en fait une copie car this ne peut être modifié resultat += duree;// on laisse fait la somme dans += pour ne pas dupliquer de code ici return resultat; }

10/10/2008, 16h40
newk++

surcharge de l'operateur+
Merci 3D Archi je te suis mieux.

Citation:

duree1 et duree2 ne sont connus comme symboles que dans main().
Dans Duree Duree::operator+(const Duree &duree), les variables connues sont this et duree. Lorsque tu fais l'appel duree1 + duree2, le compilateur se charge de faire correspondre this<->duree1 et duree<->duree2 (mécanisme de passage des paramètres).
D'ailleurs, comment ferais-tu pour
Code:

1 2 3 4 5 6 7 8 9 10 int main() { duree duree1(12,36,45); duree duree2(4,17,23); duree resultat = duree1 + duree2; duree duree3(1,7,12); duree duree4(0,08,3); resultat = duree3 + duree4; }
ce que je comprend de ce code
c'est que la meme methode operator+ fait addition des duree1 et duree2 et
et de duree3 et duree4

en consequence

dans le premier cas ce sera duree1.operator+ (duree2)
duree1 est alors le this et duree2 le parametre c-a-dire (&duree)

dans l'autre cas
ce sera duree3.operator+(duree4) et stocke cela dans resultat.
la nouvelle valeur de resultat sera alors la somme de duree3 et de duree4
duree3 est le this et duree4 sera passé alors en parametre(&duree).

merci

j'oublie quelque chose

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
 
Duree Duree::operator+(const Duree &duree)
{
    int heures = m_heures;
    int minutes = m_minutes;
    int secondes = m_secondes;
 
 
       secondes += duree.m_secondes; 
       minutes += secondes / 60;
       secondes %= 60;
 
 
    minutes += duree.m_minutes;
 
    heures += minutes / 60;
    minutes %= 60;
 
 
    heures += duree.m_heures;
 
//enfin cette ligne je ne la comprend pas du tout 
 
    // Création de l'objet resultat et retour
    Duree resultat(heures, minutes, secondes);
    return resultat;
} 
 
Puis son utilisation

Code:

1
2
3
4
 
 // Création de l'objet resultat et retour
    Duree resultat(heures, minutes, secondes);
    return resultat;

8Ocette partie du code cree un objet de type duree (resultat)oui ,automatiquement le constructeur est appelle pour initialiser ses attribut. pourquoi à t-on besoin de faire un return resultat ? 8O

10/10/2008, 18h05
Médinoc

Ben, parce que c'est ce qu'on veut faire... On veut que l'opération (duree1 + duree2) retourne un objet de type Duree contenant la somme...
10/10/2008, 21h07
newk++

ça voudrait dire qu'on peut bien se passer du return sinon lorsque on fait le return a quoi il sert je veux comprendre 8O
10/10/2008, 21h30
Médinoc

Ben si on ne faisait pas de return, le type de retour de Duree::operator+ serait forcément void, donc on ne pourrait jamais obtenir le résultat de duree1+duree2...
11/10/2008, 09h22
newk++

Mais les attributs de resultats sont deja initialisés. Donc pour y acceder depuis le main on fait resultat.afficher par exemple
11/10/2008, 11h03
Médinoc

Ça serait peut-être le cas si resultat était une variable globale, mais là il s'agit de deux variables locales.

resultat dans main() et resultat dans operator+() sont deux variables différentes, et elles pourraient avoir des noms différents.

Salut,

J'ai l'impression qu'il te manque le concept de "portée des variables" pour comprendre correctement ce qu'il se passe...

Mais pour pouvoir l'aborder, il faut déjà se mettre d'accord sur "ce qu'est une variable".

Pour toi, une variable est un nom "facile à retenir" qui permet de manipuler une instance d'un type particulier.

Pour l'ordinateur, une variable est un "symbole" qui permet d'accéder à un espace mémoire dont la taille est suffisante pour y placer les informations "transportée" par le type de la variable.

j'ai pris quelques raccourcis, mais, le principal est que tu comprenne ce que c'est ;)

Normalement, une variable existe (l'utilisateur peut utiliser son nom pour travailler avec, et l'ordinateur réserve l'espace mémoire nécessaire) entre la fin de sa déclaration et l'accolade fermante dans laquelle la déclaration se fait.

Ainsi, nous en arrivons à la situation suivante:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 void foo() { /* aucune variable n'existe */ Type a; /* à partir d'ici, a existe, mais b n'existe pas encore */ while(test) { /* a existe encore, mais b n'existe toujours pas */ AutreType b; /* a et b existent tous les deux */ } /* b est détruit et devient indisponible ici */ /* b n'existe plus, mais a continue d'exister */ } /* a est détruit et devient indisponible ici */
Comprend bien que, dans les commentaires, quand je dis "la variable existe", cela signifie que:

l'utilisateur peut utiliser le nom de la variable pour travailler dessus
l'ordinateur a réservé un espace mémoire suffisant pour y placer toutes les informations.
et que quand j'écris dans les commentaires "la variable est détruite", cela signifie que

l'utilisateur ne peut plus utiliser le nom pour travailler dessus
l'ordinateur a marqué l'espace mémoire de la variable comme pouvant être utilisé pour "autre chose" (même si ce n'est ici qu'un raccourcis pour t'aider à comprendre ;))

Si le nom d'une variable est - du point de vue de l'utilisateur - systématiquement "perdu" lorsque l'on atteint l'accolade fermante, il reste possible de modifier le moment où l'ordinateur va considérer l'espace mémoire de la variable comme "disponible pour autre chose", ainsi que quand il va considérer un espace mémoire comme "utilisé par une variable"

Ainsi, si tu renvoie une variable locale avec le mot cle return (return x; ), l'ordinateur ne rendra l'espace mémoire "disponible pour autre chose" que quand la variable de la fonction appelante qui reçoit cette variable sera elle-même détruite

De même, quand tu passe un argument à une fonction sous la forme d'une référence, le nom de l'argument agit comme un alias de la variable passée en paramètre depuis la fonction appelante: l'espace mémoire utilisé par la variable de la fonction appelante est le même que celui utilisé par l'argument dans la fonction appelée.

(il serait possible de parler aussi des référence constante avec valeur par défaut, mais nous n'allons pas compliquer dans un premier temps ;))
Le résultat, c'est que:

toute modification de l'argument dans la fonction appelée sera répercutée dans la fonction appelante sur la variable passée en paramètre
l'ordinateur ne s'inquiète pas de l'espace mémoire dans la fonction appelée: toute la gestion de l'espace mémoire se fait dans la fonction appelante.

Enfin, il y a le cas particulier des pointeurs, et de la gestion dynamique de la mémoire.

Encore une fois, il s'agit d'un raccourcis pour te permettre de comprendre, mais un pointeur n'est jamais qu'une variable particulière en cela qu'elle contient l'adresse d'un espace mémoire à laquelle l'ordinateur pourra trouver l'instance réel de l'objet dont le type correspond.

Il y a donc, au niveau de l'ordinateur une "double gestion" des espaces mémoire: celle de la variable de type "pointeur sur", qui suit les règles énoncées plus haut, et celle propre à "l'élément pointé par" le pointeur, qui *peut* (car il est toujours possible de demander d'utiliser "l'adresse d'une variable" pour obtenir un pointeur) être soumis à l'allocation dynamique.

Le principe de l'allocation dynamique est de dire à l'ordinateur "je sais ce que je fais, laisse moi gérer moi même l'utilisation de cette mémoire".

Tu peux donc lui demander de réserver de la mémoire avec les mots clé new et new[] et de la libérer avec les mots clé delete et delete[].

Seulement, en brave petit soldat, l'ordinateur respecte ta décision: comme tu lui a demandé de gérer toi même la mémoire, il ne s'en occupera pas du tout.

Il sera donc de ton devoir de veiller à ce que l'espace mémoire réservé par new ou par new[] soit libéré (par le delete ou le delete[] correspondant) tant que tu a acces à la variable de type "pointeur sur".

Maintenant, tu devrais comprendre pourquoi il manque le "return" dans le code présenté plus haut ;)

13/10/2008, 09h09
3DArchi

Je crois que la réponse de koala01 est assez complète et bien précise. Je rajouterais uniquement ce point: le nom de la variable n'a pas de sens pour le compilateur. Que tu appelles celle-ci 'paramètre' ou 'résultat' ne sera pas interprété par le compilateur comme devant être un paramètre ou un résultat. C'est pourquoi il y a des conventions d'écriture dans la déclaration des méthodes, leur invocation ou des mots clés comme 'return' pour préciser quelles sont les informations à retourner. Leur sens en français n'est là que pour aider le développeur à comprendre la fonction sans analyser trop en détail son comportement exact. C'est pourquoi il est intéressant de donner aux variables des noms qui signifie quelque chose et qu'elle fasse effectivement ce qu'elle signifie.