Discussion :

[joe230]

Voilà, j'ai quelques petits problèmes quand il s'agit d'appliquer la surcharge de l'opérateur + dans mon application...
Je m'explique : J'ai une classe Agenda, qui comporte comme attribut un vector contenant des pointeurs vers des instances de la classe RendezVous.
La classe RendezVous, quand à elle, comporte en attribut une instance de la classe Date, et une instance de la classe Horaire.

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
 
class Agenda
{
    private:
 
        vector<RendezVous*>mesRdv;
.
.
}
 
 
class RendezVous
{
    private:
 
        Date dateRdv;
        Horaire horaireRdv;
.
.
}

Ma classe horaire ne comporte que deux attributs, qui sont minute en entier court, et heure, également en entier court :

Code :

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

1
2
3
4
5
6
7
8
9
10
 
class Horaire
{
    private:
 
        short int heure;
        short int minute;
.
.
}

J'aimerai pouvoir surcharger l'opérateur + dans la classe Horaire, afin de me permettre d'augmenter les minutes d'un horaire et ainsi d'obtenir un nouvel horaire remplaçant celui qui a été modifié.
Le prototype serait donc, normallement :

Code :

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

Horaire operator+(Horaire &unHoraire)

Après je suis pas sûr de l'implémentation de cette surcharge mais voici ce que j'ai fait, pour le moment :

Code :

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

1
2
3
4
5
 
Horaire Horaire::operator+(Horaire &unHoraire)
{	
	return Horaire(heure, minute + unHoraire.minute);
}

Le prototype et l'implémentation sont-elle bonne ? Comment puis-je utiliser cette fonction ?Sachant que dans mon menu principal (dans le main) il faudra rajouter la possibilité de d'ajouter des minutes a un horaire, donc de choisir un rendez-vous dans l'agenda afin d'en modifier l'horaire...bref l'utilisation de cette méthode me parait complètement floue...aidez-moi SVP!!!!
Merci d'avance!

[bolhrak]

de la manière dont tu nous le presente, ton code va modifier l'horraire appleant (a gauche de l'operateur) en rajoutant les minutes de celui appelé ( à droite de l'operateur).

Non, son code crée un nouvel Horaire, en aucun cas les valeurs de heure et minute de l'objet sur lequel le code est appelé ne sont modifiés.

Mais a ce stade aucun Horraire est detruit.

L'argument a été passé par référence, le paramètre de retour est retourné par valeur (donc copie + destruction automatique), il n'y a donc rien à détruire.

Un truc plus simpa (je sais pas si tu en as besoin) serait de fussioner deux Horraire dans l'operateur "+". Supprimer le deuxième objet apres l'avoir reporter dans le premier. Exemple :

Code :

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

1
2
3
4
5
6
7
Horaire Horaire::operator+(Horaire &unHoraire)
{
this.minute += unHoraire.minute;
delete unHoraire;
unHoraire = NULL;
return this;
}

bon faut toujours tester son pointeur avant de l'utiliser.

Le paramètre unHoraire est une référence, pas un pointeur !

Code :

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

1
2
3
 
delete unHoraire;
unHoraire = Null;

Code totalement invalide, ça ne compilera pas.

Code :

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

1
2
 
return this;

this est de type Horaire*, le type de retour de la fonction est de type Horaire, donc encore une fois code invalide.

Les opérateurs mathématiques sont utilisés lorsque tu souhaites manipuler tes objets par valeur. Autrement dit, pour modifier un horaire via opérateur +, tu en crées un troisième à partier des deux premiers :

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
 
 
class Horaire {
 
public:
 
    Horaire& operator+=(const Horaire& horaire) {
        short int totalMinutes = horaire.minute + minute;
        heure+=(totalMinutes-totalMinutes%60)/60;
        minute+=totalMinutes%60;
        return *this;
    }
 
//...
};
 
//Défini hors de la classe
Horaire operator+(const Horaire& horaire1, const Horaire& horaire2) {
    Horaire result = horaire1;
    return result+=horaire2;
}

Ainsi si tu veux modifier un objet de type horaire particulier, tu utilises l'opérateur +=, si tu souhaites en crées un troisième en en additionnant deux, tu utilises l'opérateur +.

[joe230]

Merci pour vos réponses!
En fait je me suis aperçu (grâce à vous) que la surcharge de l'opérateur + n'était pas appropriée ici.
En effet je souhaite simplement augmenter les minutes d'un horaire spécifique à un rendez-vous, il suffit donc de sélectionner le rendez-vous et d'utiliser une fonction membre du genre

Code :

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

short int AugmenterMinute(short int minutesEnPlus);

Car si j'ai bien compris, l'utilisation des surcharges d'opérateurs ne sont utiles que lorsqu'elles sont appliquées à des objets, ce qui signifie donc qu'il aurait fallu que je créé une nouvelle instance de Horaire pour l'ajouter à celui que je souhaite modifier, ce qui me semble inutile juste pour modifier les minutes d'une instance déjà existante...

En tout cas merci, j'ai les idées bien plus claires à présent!