Discussion :

[mouadmagan]

Bonjour ,

J'ai de gros problemes en langage c ++ ,

Voici l'enoncé de l'exercice que je devrais faire ,

```
définir la classe d'objets Heure , qui implante ce type de données , sous
la forme de 2 entiers Heure et minutes. ce type sera utilisé pour
representer , par exemple , l'horaire de départ d'un train , ou la duré
d'un voyage ..

la classe fournira les méthodes suivantes :

- le constructeur qui permet d'instancier une Heure à partir de valeurs
fournies ( heures et minutes , ou minutes seulement ) .

Ex: Heure h1(500) , h2(13,27) ;

- la methode virtuelle Minutes qui calcule le nombre de minutes écoulés.

Ex : 13H27 produira le nombre 807 ( 13*60 + 27 )

- la surcharge de l'operateur + qui calcule l'heure obtenue , en ajoutant
un nombre de minutes à la valeur d'un objet heure .

- la surcharge de l'operateur - qui calculera la difference entre deux
heures de la meme journée , et produira un nombre de minutes comme
résultat. exemple : 13H27 - 17h57 = 270 .

- la surcharge de l'operateur > pour comparer deux heures .

```

Ma Solution :

Classe Heure.h :

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
class heure
{
	public:
		// class constructor
		heure();
		heure(int,int);
		heure(int);
		virtual heure Minutes(int,int);
		friend heure operator+(heure,int);
		friend int operator-(heure,heure);
		friend bool operator > (heure,heure);
		void afficher();
 
 
		private:
                int heures;
                int minute;
};

Heure.CPP ::

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
36
37
38
39
40
41
42
#include "heure.h"
#include <iostream> 
 
using namespace std;
 
heure::heure()
{
 
}
 
heure::heure(int m)
{
	minute=m;
}
 
heure::heure(int h,int m)
{
    heures=h;
	minute=m;
}
 
heure heure::Minutes(int h,int m)
{
 int c;
 c=h*60+m;
 return heure(c);   
 
}
 
heure operator +(heure h ,int m )
{
     h.heures=(h.minute+m)/60 + h.heures;
     h.minute=(h.minute+m)%60;
     return heure(h.heures,h.minute);
 
      }
 
void heure::afficher()
{
     cout<< "l'heure est : " << heures << " nombre de minutes est : " << minute ;
 
     }

Est ce que quelqu'un pourrait corriger les erreurs si existant .???

MERCI

[gbdivers]

Bonsoir

Première relecture rapide :
- pense à "protéger" ton fichier d'en-tête avec #ifndef ;
- mettre explicit devant le constructeur à 1 paramètre heure(int); ;
- initialisation des variables membres
- pourquoi des friend ?
- opérateur comme fonction membre ou comme fonction libre ? (lié à la question précédente)
- quel est ton invariant de classe ? en particulier les limites des variables membres. Par exemple, si on fait :

Code :

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

1
2
heure h(600);
h.affiche();

affiche : l'heure est : 0 nombre de minutes est : 600 au lieu d'affficher 10 heures
- la syntaxe des opérateurs n'est pas correcte
- il manque le code des opérateurs
- choix des noms "dangereux" je pense : heure (classe) proche de heures (variable membre). Perso, j'écris les noms de classe en majuscule (UnNomDeClasse), les variables membres avec un préfix "m_" (m_uneVariableMembre), les fonctions commence avec une minuscule (uneFonctionMembre), etc. (les conventions de style change avec les libs, prend par exemple la stl comme base)

[Emmanuel Deloget]

Je complète.

Bonsoir

Première relecture rapide :
- pense à "protéger" ton fichier d'en-tête avec #ifndef ;
- mettre explicit devant le constructeur à 1 paramètre heure(int); ;

Ce n'est pas "nécessaire"(*), mais ça peut éviter des erreurs tordues.

- initialisation des variables membres

Ca, par contre, c'est vraiment nécessaire. Je te conseille en outre de lorgner du coté des listes d'initialisation, qui sont plus lisibles (et plus efficaces) que les assignation dans le constructeur.

- pourquoi des friend ?
- opérateur comme fonction membre ou comme fonction libre ? (lié à la question précédente)

Idem.

Ceci dit, vu l'apport en termes d'encapsulation, je penche pour des fonctions libres qui ne sont pas friend.

- quel est ton invariant de classe ? en particulier les limites des variables membres. Par exemple, si on fait :

Code :

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

1
2
heure h(600);
h.affiche();

affiche : l'heure est : 0 nombre de minutes est : 600 au lieu d'affficher 10 heures

Ce n'est que sous-entendu dans l'énoncé, mais lorsqu'on conçoit un programme, on se doit de faire en sorte qu'il fonctionne sur un principe pragmatique dit de "moindre surprise", c'est à dire que lorsqu'une information nous manque (dans un énoncé d'exercice ou dans un cahier des charges), qu'il existe une réponse triviale pour palier à ce manque, et que cette réponse triviale correspond à un fonctionnement que tout un chacun est en droit d'attendre, alors il faut implémenter cette réponse triviale.

Dans ton cas, ça veut surtout dire que lorsque tu manipule des minutes, si le nombre de minutes est >= 60, alors il faudra penser à passer en heures. Tu l'as fait pour l'opérateur + (encore que le calcul me paraisse étrange ; mais en même temps, 1h du matin + pastis + fatigue, ça n'aide pas, et ça donne pas envie de réfléchir).

- la syntaxe des opérateurs n'est pas correcte
- il manque le code des opérateurs

Idem. Reporte toi à ton cours pour savoir quelle syntaxe il faut utiliser. Pour le code des opérateurs, et bien c'est justement la partie fine à faire - donc tu m'excuseras si je ne l'écris pas.

- choix des noms "dangereux" je pense : heure (classe) proche de heures (variable membre). Perso, j'écris les noms de classe en majuscule (UnNomDeClasse), les variables membres avec un préfix "m_" (m_uneVariableMembre), les fonctions commence avec une minuscule (uneFonctionMembre), etc. (les conventions de style change avec les libs, prend par exemple la stl comme base)

Gros point que voilà.

La STL n'est pas forcément un exemple à prendre, du fait de sa complexité qui rends la lecture du code presque impossible pour un débutant.

Personnellement, j'utilise une notation minuscules + underscore, et mes le nom de mes variables membres d'une classe est préfixé de m_.

Ca donne par exemple :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
class heure
{
private:
  unsigned int m_heures;
  unsigned int m_minutes;
public:
  // ... toutes les méthodes de base : ctor, dtor, operator+...
  unsigned int distance_vers_minuit_en_minutes()
  {
     unsigned int minuit = 24 * 60;
     return  minuit - ((m_heure * 60 + m_minutes) % minuit);
  }
};

Bien évidemment, le nom choisi est extrêmement descriptif, mais ça donne un exemple.

Des remarques supplémentaires :

* attention à l'indentation : une indentation correcte va te permettre de lire plus facilement ton code, et donc de mieux détecter les problèmes potentiels ou de comprendre plus facilement ce que tu as écris.

* dans heure.h, les paramètres sont types (c'est le strict nécessaire). Les nommer permet de simplifier la relecture du code. En lisant heure.h, je ne sais pas ce que représente le paramètre unique du constructeur heure(int). C'est un nombre d'heures ? de minutes ? de jours ?


(*) en fait si, c'est nécessaire, mais ça l'est uniquement parce que les bugs qui peuvent arriver si tu ne le mets pas sont bien souvent trop difficile à tracer.

[gbdivers]

La STL n'est pas forcément un exemple à prendre, du fait de sa complexité qui rends la lecture du code presque impossible pour un débutant.

Personnellement, j'utilise une notation minuscules + underscore, et mes le nom de mes variables membres d'une classe est préfixé de m_.

Perso, j'ai tendance à suivre la syntaxe de Qt par habitude, je n'aime pas non plus celle de la STL. C'était à titre d'exemple (et normalement, la STL est connu de tous ceux qui font du C++...)

Pour le reste, je laisse le PO bosser un peu

Ce n'est pas "nécessaire"(*), mais ça peut éviter des erreurs tordues.

J'ai tendance à préférer le mettre par défaut et le supprimer que si cela à un sens

[Emmanuel Deloget]

(et normalement, la STL est connu de tous ceux qui font du C++...)

Ce qui, dans ce cas, risque fort de se révéler ne pas être le cas, le PO semblant - peut être à son corps défendant, même si j'ai l'intuition qu'il n'en est rien - être débutant dans ce domaine, et non, ne vous affolez pas, c'est bien l'alcool qui me fait écrire d'une manière aussi formelle

[mouadmagan]

Bonsoir ,

tout d'abord, Je tiens à vous remercier ...

j'ai pas trop bien compris ce que vous veniez de dire , mais je voudrais savoir pourquoi la syntaxe de l’opérateur est incorrecte , que dois-je faire exactement ?

Et , pourquoi le calcul, pour ajouter le nombre de minutes à une heure donnée, vous parait étrange ?? est ce que ça mene à une erreur ? dans ce cas j'aimerai bien me proposer une solution

Et Je saisis pas tres bien la notion " friend " parce que dans les tp qu'on faisait , on la met lorsqu'on veut surcharger un operateur .. et j'en ai aucune idée à quoi sert , concretement ... sinon , si j'ai raison , on peut faire appel aux variables membres depuis l'exterieur si on travaille avec les " friend " .. mais on les mettais juste lorsqu'on on voulait surcharger des operateurs ... ????

autre question , je sais pas pourquoi dans la fonction main ,quand je veux afficher par exemple H1(500) [ le nombre de minutes seulement, qui vaut 500 ] m'affiche autre chose genre : l'heure est : 88 ..nombre de minutes est : 500 ?? mais d'ou vient le 88 ?? alors que moi j'en ai envie qu'afficher les minutes seulement


Sinon , c'est pas vraiment necessaire si je prend en compte minuit ou matin ... c'est vrai qu'il est indispensable d'y reflechir à ça .. mais c'est pas vraiment mon probleme ..


MERCI DE ME REPONDRE

[Daïmanu]

Les opérateurs doivent prendre des references constantes pour des questions de performance (nottament éviter les contructions / destructions inutiles).

De plus, le compilateur sait que le 1er argument des opértaurs est une réference vers une instance de ta classe, puisque tu a déclaré les opérateurs à l'intérieur de ta classe. Ca veut dire qu'il ne faut qu'un seul argument à tes opérateurs.

Quant aux friends, ils permettent de passer outre la "vie privée" des variables privées. On peut s'en passer à condition de créer des "getter" et des "setter" dans la classe, et de les utiliser dans l'implémentation de tes opérateurs.

Donc tes

Code :

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

1
2
3
4
 
friend heure operator+(heure,int);
friend int operator-(heure,heure);
friend bool operator > (heure,heure);

deviennent des

Code :

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

1
2
3
4
5
 
heure operator + (const int&);
int   operator - (const heure&);
bool  operator > (const heure&);
// Une belle indentation est agréable aussi

Plus d'infos sur la syntaxe des opérateurs : http://en.wikipedia.org/wiki/Operators_in_C_and_C%2B%2B

[kessoufi]

Salut

autres remarques :

- la classe a une fonction virtuelle, cela suppose qu'elle est destinée à être dérivée, pense à ajouter un destructeur virtuel.

- je m'attendais à ce que Minutes retourne un entier, là tu renvoies juste une autre représentation de *this

- le constructeur heure(m) ne calcule pas les heures, si pour toi 0h70 est une valeur normale ok, mais dans ce cas tu auras besoin de tout ramener aux minutes pour chaque comparaison d'heures
cela rejoint la question sur les invariants de ta classe

- dans h2(13,27) il est facile pour un utilisateur de se planter sur l'ordre des arguments, il est peut être préférable d'utiliser un named constructor, genre :

Code :

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

1
2
 
 heure HeuresPuisMinutes(13,27);

ok, on peut faire mieux pour le choix du nom, mais l'idée est là.

Cdt

[Emmanuel Deloget]

- dans h2(13,27) il est facile pour un utilisateur de se planter sur l'ordre des arguments, il est peut être préférable d'utiliser un named constructor, genre :

Code :

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

1
2
 
 heure HeuresPuisMinutes(13,27);

ok, on peut faire mieux pour le choix du nom, mais l'idée est là.

Là, ça quitte l'énoncé

[koala01]

Salut,

Salut

autres remarques :

- la classe a une fonction virtuelle, cela suppose qu'elle est destinée à être dérivée, pense à ajouter un destructeur virtuel.

- je m'attendais à ce que Minutes retourne un entier, là tu renvoies juste une autre représentation de *this

- le constructeur heure(m) ne calcule pas les heures, si pour toi 0h70 est une valeur normale ok, mais dans ce cas tu auras besoin de tout ramener aux minutes pour chaque comparaison d'heures
cela rejoint la question sur les invariants de ta classe

- dans h2(13,27) il est facile pour un utilisateur de se planter sur l'ordre des arguments, il est peut être préférable d'utiliser un named constructor, genre :

Code :

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

1
2
 
 heure HeuresPuisMinutes(13,27);

ok, on peut faire mieux pour le choix du nom, mais l'idée est là.

Cdt

Je ne suis pas vraiment partisant des "named constructors"...

Par contre, il faudrait placer des préconditions permettant de tester si, oui ou non, nous sommes dans une tranche horraire cohérente:

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
Heure::Heure(int heure, int minute):heure_(heure),minute_(minute)
{
    check();
}
Heure::Heure(int timeInMinuts ) : heure_(timeInMinuts/60), 
                                  minute_(timeInMinuts%60)
{
    //en théorie inutile ici, mais pour garde la même logique :-D
    check();
}
void Heure::check() const
{
    assert(heure_ >= 0);
    assert(heure_ <  24);
    assert(minute_ >= 0):
    assert(minute_ < 60 );
}

Tu ne pourras effectivement pas éviter que l'utilisateur introduise 12, 13 alors qu'il veut intrduire l'heure 13h12, mais c'est la raison d'être du nommage correct des arguments, et, contre la bêtise humaine, on ne peut rien

[mouadmagan]

Bonjour ,

Merci De Vos Réponses ,

alors , si je mets mes constructeurs sur cette forme la ,

Code :

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

1
2
3
heure operator + (const int&);
int   operator - (const heure&);
bool  operator > (const heure&);

je devrais obligatoirement ajouter des accesseurs ?? c'est ça ?? mais s'il n'est pas demandé de le faire , et de travailler normalement , la syntaxe des opérateurs dont je travaille est elle correcte ???

- et pour la methode minutes , qui renvoie le nombre de minutes , est ce qu'elle est correcte , ou bien devrait t-elle retourner un entier ?

- en ce qui concerne le constructeur qui prend qu'un seul parametre , je veux seulement recuperer le nombre de minutes tel qu'il est .. par exemple heure (500) doit renvoyer heure 0 : minutes 500 ...


et je comprends pas ce que ' les invariants de la classe ' veut dire , si vous pourriez m'expliquer cela s'il vous plait .


MERCI

[koala01]

alors , si je mets mes constructeurs sur cette forme la ,

Code :

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

1
2
3
heure operator + (const int&);
int   operator - (const heure&);
bool  operator > (const heure&);

je devrais obligatoirement ajouter des accesseurs ?? c'est ça ??

La réponse courte est: non : comme tu dispose de toutes manières de la fonction minutes qui te renvoie la valeur qui te permettra le plus facilement de calculer le résultat, tu n'as de toutes manières pas besoin d'accesseurs (après tout, cette fonction minutes agit strictement comme un accesseurs ) (*)


Tu pourrais donc écrire ton opérateur + sous la forme de

Code :

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

1
2
3
4
5
6
Heure operator + (Heure const & first, Heure const & second)
{
    // la version longue pour la compréhension :D
    int result = first.minutes() + second.minutes();
    return Heure(result);
}

et les opérateurs == et < seraient du même tonneau

(*) Il en irait différemment si tu ne disposais pas de cette fonction, mais, comme elle existe, pourquoi se faire du mal inutilement
Ceci dit, il pourrait, plus tard, s'avérer intéressant de pouvoir récupérer les heures d'un coté et les minutes (depuis le début de l'heure) de l'autre

La réponse longue, maintenant:Cela va dépendre de si tes opérateurs sont membres de la classe (ou amis de la classe) ou non.

S'ils sont membres de la classe (c'est à dire qu'ils seront déclarés et implémentés comme n'importe quelle autre fonction membre ) ou qu'ils sont amis de la classe, tu n'auras absolument pas besoin de rajouter des accesseurs : ils auront, naturellement, accès à l'ensemble de la classe, y compris aux membres privés.

S'il sont implémentés comme des fonctions libres, il faudra, en tout cas, disposer de fonctions qui te permettent de récupérer les valeurs qui t'intéressent.

Cela impliquera donc soit de créer des accesseurs sur heure et sur minutes et d'effectuer le calcul d'une manière ou d'une autre, soit, étant donné qu'elle t'est demandée, d'utiliser la fonction minutes qui fournit exactement le genre de valeur qui peut nous intéresser

mais s'il n'est pas demandé de le faire , et de travailler normalement , la syntaxe des opérateurs dont je travaille est elle correcte ???

Là encore, cela va dépendre de si tu crées des fonctions membres, ou si tu créees des fonctions amies ou des fonctions libres.

Dans le cas de fonctions membres, le premier opérande est implicite grâce à la connaissance qu'ont toutes les fonctions membres de l'objet au départ duquel elles ont été appelées ( "this")

Dans le cas où il s'agit de fonctions amies ou de fonctions libres les opérateurs +, < et == ont nécessairement besoin de deux arguments qui représentent respectivement l'opérande de gauche et celui de droite.

Mais, dans tous les cas, les arguments devront être passés par référence constante

- et pour la methode minutes , qui renvoie le nombre de minutes , est ce qu'elle est correcte , ou bien devrait t-elle retourner un entier ?

Réfléchis juste un peu, voyons... l'énoncé te dit qu'elle doit renvoyer le... nombre de minutes

Selon toi, est-ce qu'un nombre de minutes et une Heure, ou est-ce une équivalence

- en ce qui concerne le constructeur qui prend qu'un seul parametre , je veux seulement recuperer le nombre de minutes tel qu'il est .. par exemple heure (500) doit renvoyer heure 0 : minutes 500 ...

C'est tout sauf sensé...

Tu crée une classe qui va permettre de représenter... des heures, donc, classiquement, qui va "cumuler" deux valeurs intimement liées et devant respecter certaine contraintes : quand minute <59, il faut soustraire 60 à minutes et incrémenter heure.

Et là, tu nous dit que tu veux simplement récupérer 500 si l'utilisateur introduit ce nombre !!!

A quoi servirait alors de créer une telle classe !!!

Ce serait d'autant plus idiot que l'énoncé te demande justement d'écrire une fonction "minutes()" dont le but est de te renvoyer l'équivalence sous forme de minutes (donc 500 au lieu de 8 heures et 40 minutes) !!!

et je comprends pas ce que ' les invariants de la classe ' veut dire , si vous pourriez m'expliquer cela s'il vous plait .

Les invariants d'une classe regroupent toutes les règles qu'une instance de classe se doit de respecter pour qu'elle puisse être considérée comme valide, et donc utilisable.

Ces règles peuvent reprendre des valeurs minimales et / ou maximales admissibles pour certains membres (dans le cas présent, la valeur représentant les heures doit être comprise entre 0 et 24 inclus et celle représentant les minutes entre 0 et 59 inclus) ou des "états" particuliers (on pourrait envisager qu'un objet ne soit considéré comme valide que s'il dispose de X éléments particuliers).

Elles seront généralement testées en pré condition dans les fonctions membres de l'objet (car le comportement ne pourra être certifié que si les règles sont respectée) et en post conditions dans les fonctions utilisatrices parce que l'utilisation d'un objet invalide peut mener à des catastrophes

[mouadmagan]

Bonsoiir ,

est-ce possible de définir mes opérateurs comme suit ???

Code :

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

1
2
3
4
5
6
7
8
heure operator + (heure h , int m)
{
heure k;
k.m_minute=(h.m_minute+m) % 60;
k.m_heure=(h.m_inute+m)/60 + h.m_heure;
 
return heure(k.m_heure,k.m_minute);
}

ET :

Code :

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

1
2
3
4
5
6
int operator - (heure h1,heure h2)
{
int c;
c=h1.minutes(h1.m_heure,h1.m_minute) -h2.minutes(h2.m_heure,h2.m_minute);
return c;
}

sachant que : la méthode minutes est définit comme suit :

Code :

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

1
2
3
4
5
6
7
int heure::minutes(int h,int m)
{
int c ;
 
c=h*60+m;
return c;
}

est ce que les opérateurs peuvent déjà retourner un type différent de l'objet heure ?? [ mentionné en rouge ]


MERCI

[koala01]

Tu sais, il exsite un outil génial, pour faire des essais... cela s'appelle un compilateur!

Il te dira tout de suite si ce que tu fais peut être considéré comme valide

Mais là, je ne te vois déjà pas utiliser la fonction minutes...

Dans le meilleurs des cas, tu utilise les variables membres m_inute et m_heure de ta classe (pour autant qu'ils existent).

De plus, l'opérateur + va ajouter un entier (des minutes, visiblement ) à des heures, ce qui est cohérent avec ce que l'on peut en attendre... mais ne te semblerait il pas plus cohérent encore d'être en mesure d'ajouter des heures à... tes heures

est ce que les opérateurs peuvent déjà retourner un type différent de l'objet heure ??

Mon compilateur l'accepte, avec raison parce que les opérateurs peuvent jouer le rôle d'opérateurs de conversion.

Encore faut il que ce soit cohérent avec ce à quoi va s'attendre l'utilisateur !!!

Or, la plupart de ceux-ci s'attendront sans doute, s'ils effectuent des opérations sur des heures, à obtenir un résultat sous la forme ... d'heures, non

Enfin, ta fonction minutes ne doit absolument pas prendre d'arguments !

Le principe à garder en mémoire, c'est que, classiquement, les arguments servent à passer à une fonction des valeurs qu'elle est dans l'incapacité d'obtenir par ailleurs, c'est à dire, pour une fonction membre d'une classe, des valeur qui ne lui viennent pas des membres de la classe et qui ne sont pas des constantes que tu pourrais définir directement dans le code de la fonction .

Comme c'est une fonction membre non statique (retiens juste le terme, nous n'allons pas t'embrouiller d'avantage avec ca pour l'instant ) de ta classe, elle a accès aux variables membres de l'instance (la variable de type Heure ) à partir de laquelle elle est appelée.

h2.minutes peut donc directement accéder aux membres m_inute et m_heure de... h2. Pourquoi voudrais tu devoir les repasser en paramètres

De plus, tu ne pourrais y accéder depuis l'opérateur - que si celui-ci dispose au minimum d'une relation d'amitié avec ta classe heure!!!

Mais que se passerait il si tu voulais récupérer le nombre de minutes représentant ton heure depuis une fonction qui n'a strictement rien à voir avec la classe Heure (au pif, comme cela, la fonction principale main() )

Essaye simplement de compiler le code

Code :

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

1
2
3
4
5
6
7
8
int main()
{
    Heure h(145);
    /* ca devrait nous renvoyer 145 :-D... si ca marche :-$ */
    int lesMinutes =  h.minutes(h.m_heure,h.m_minutes);
    std::cout<<lesMinutes;
    return 0;
}

pour observer de toi meme ce qui va se passer

La suite au prochain épisode, car je dois me mettre en route

[mouadmagan]

Bonjour ,

une autre version plus correcte :

Code :

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

1
2
3
4
5
6
7
heure operator + (heure h , int m)
{
     int k;
     k=h.minutes+m;
 
     return heure ( k / 60 ,  k % 60 );
}

Code :

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

1
2
3
4
5
6
heure operator - (heure h1,heure h2)
{
        int c;
        c=h1.minutes-h2.minutes();
        return heure(c);
}

Code :

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

1
2
3
4
5
6
int heure::minutes()
{
    int c,
    c=m_heure*60+m_minute;
    return c;
}

Y a t-il d'autres propositions s'il vous plait ??

[mouadmagan]

ce bout de code :

Code :

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

1
2
3
4
5
6
7
8
int main()
{
    Heure h(145);
    /* ca devrait nous renvoyer 145 :-D... si ca marche :-$ */
    int lesMinutes =  h.minutes(h.m_heure,h.m_minutes);
    std::cout<<lesMinutes;
    return 0;
}

m'affiche une erreur genre : m_minute et m_heure sont privés ..

[koala01]

Il y a deux versions possibles pour l'opérateur +, en fonction libre :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
Heure operator + (Heure const & lho, Heure const & rho) // on donne deux
                                                                           // heures valides
{
    int lesMinutes = lho.minutes() + rho.minutes();
    return Heure(lesMinutes);
}
/* une version où l'on donne une heure et un nombre de minutes */
Heure operator + (Heure const & lho, int minToAdd) 
{
    int lesMinutes = lho.minutes() + minToAdd;
    return Heure(lesMinutes);
}

que nous pourrions avoir sous la forme de fonction membres de la classe :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
Heure Heure::operator + (Heure const & rho) 
{
    int lesMinutes = minutes() + rho.minutes();
    return Heure(lesMinutes);
}
/* une version où l'on donne un nombre de minutes */
Heure Heure::operator + (int minToAdd) 
{
    int lesMinutes = minutes() + minToAdd;
    return Heure(lesMinutes);
}

m'affiche une erreur genre : m_minute et m_heure sont privés ..

Et c'est normal, l'accessibilité privée est l'une des base permettant l'encapsulation : si tu essaye d'accéder, depuis une fonction qui n'est pas membre d'une classe à l'un des membres privés de la classe, le compilateur se plaint du fait que tu ne peux pas y accéder

Si tu n'avais pas compris à quoi servait le mot clé private et ce que permettait le mot friend, tu as maintenant un exemple qui devrais te mettre sur la voie de leur utilité

[Emmanuel Deloget]

ce bout de code :

Code :

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

1
2
3
4
5
6
7
8
int main()
{
    Heure h(145);
    /* ca devrait nous renvoyer 145 :-D... si ca marche :-$ */
    int lesMinutes =  h.minutes(h.m_heure,h.m_minutes);
    std::cout<<lesMinutes;
    return 0;
}

m'affiche une erreur genre : m_minute et m_heure sont privés ..

Normal, parce que m_heure et m_minutes sont... privés

Il est difficile d'expliquer quelque chose lorsque la personne en face ne prends pas la peine de tenter de comprendre ne serait-ce que les concepts de base du langage (classes, accès public, protégé, privé, etc ; bref, les 3 ou 4 premiers chapitres de tout bouquin de C++ qui se respecte).