objet en paramètre

Version imprimable

objet en paramètre

Salut tous,

J'essaye de créer une classe simple avec comme attribut un objet d'une autre classe, mon problème est le constructeur :

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
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
 
class uneDate
{
    private :
    int sonJour, sonMois, sonAnnee;
 
    public:
    uneDate(int,int,int);
    uneDate(const uneDate &);
    void afficheToi();
    void setDate(int, int, int);
    int getJour();
    int getMois();
    int getAnnee();
};
 
uneDate :: uneDate(int j, int m, int a)
{
    sonJour = j;
    sonMois = m;
    sonAnnee = a;
}
 
uneDate :: uneDate(const uneDate & D)
{
    sonJour = D.sonJour;
    sonMois = D.sonMois;
    sonAnnee = D.sonAnnee;
}
 
void uneDate :: afficheToi()
{
    cout<<sonJour<<"/"<<sonMois<<"/"<<sonAnnee<<endl;
}
 
void uneDate :: setDate(int j, int m, int a)
{
    sonJour = j;
    sonMois = m;
    sonAnnee = a;
}
 
int uneDate :: getJour(){return sonJour;}
int uneDate :: getMois(){return sonMois;}
int uneDate :: getAnnee(){return sonAnnee;}
 
class unEvenement
{
    private :
    uneDate saDate;
    char * intitule;
 
    public:
    unEvenement(uneDate , char * intitule);
    void afficheToi();
};
 
unEvenement :: unEvenement(uneDate  D, char * intit)
{
    saDate.setDate(D.getJour(), D.getMois(), D.getAnnee());
    strcpy(intitule, intit);
}
 
void unEvenement :: afficheToi()
{
    saDate.afficheToi();
    cout<<intitule<<endl;
}

Donc pour construire un objet unEvenement, il faut bien transmettre par valeur uneDate D, pour cela j'ai prévu un constructeur par recopie...Vainement semble-t-il, le compilateur me renvoie une erreur :
no matching function for call to 'uneDate :: uneDate()'
Un constructeur par défaut, qu'est-ce qu'il va en faire ? Franchement... Mon compilateur est-il drogué ?

22/04/2011, 00h50
Epsilon012
Dans le constructeur de unEvenement, que fait tu de saDate ? Rien. Donc il est initialisé sans argument.
Code:

1 2 3 4 unEvenement :: unEvenement(uneDate D, char * intit): saDate(D) { strcpy(intitule, intit); }
Fonctionnera mieux.

Je ne sais pas si c'est un devoir ou si tu es en train d'apprendre le C++ par toi même, dans tout les cas, t'apprendra plus vite, plus de choses en lisant un bon livre que ton bout de code fait très C là… avec le mot clef class en plus.
22/04/2011, 09h42
Oussapik
Pour ton problème, je vois plusieurs solutions :
1. Passer une référence à ton constructeur d'événement. Ainsi, tu es sur d'avoir le même élément en dehors et dans ton événement en ce qui concerne la date
2. Passer directement l'objet de type uneDate au constructeur. Là, je ne vois pas en quoi il y aurait un problème. Tu peux très bien faire celà. Cependant, si tu modifie l'objet dans ton événement, l'objet fourni au constructeur ne sera pas modifié
Peut-on voir le bout de code que tu utilises pour tester ceci ? il me semble qu'il manque une partie pour que l'on comprenne comment tu appelles les différentes méthodes ici présentes :)

Autre point qui ne concerne pas ton problème mais qui simplifiera la relecture de ton code. Le nom de tes classes ne reflète pas ce qu'elles sont.
Quand je regarde ta classe uneDate, elle a un jour, un mois et une année. La classe devrait donc s'appeler "Date" uniquement. Et une instance de date pourrait être appelée "uneDate".
De la même manière, les attributs n'ont pas besoin de préciser leur appartenance à la classe dans leur nom, c'est implicite du fait que ce sont des attributs. Ainsi, tu peux écrire "jour" au lieur de "sonJour" par exemple.

Salut,

Pour commencer, j'aurais quelques remarques à faire sur ta classe uneDate:

Tu devrais utiliser les listes d'initialisation dans tes constructeurs. Dans le cas présent, tu n'auras pas beaucoup d'avantages, mais, de manière générale, cela te permet d'initilaliser directement les membres de ta classe avec les bonnes valeurs plutôt que de passer par une double procédure d'initialisation à des valeurs par défaut suivie d'une affectation (et donc d'une copie) des membres.

Les constructeurs prendraient donc des formes proches de
Code:

1 2 3 4 5 6 uneDate::uneDate(int j, int m, int a) : sonJour (j), sonMois(m), sonAnnee(a){} uneDate::uneDate(uneDate const & other):sonJour (other.sonJour ), sonMois(other.sonMois), sonAnnee(other.sonAnnee){}
Ensuite, il faut savoir qu'il existe quatre fonctions qui seront systématiquement créée par le compilateur si tu ne les déclare pas toi-même:

Le constructeur par défaut (qui ne sera pas créé par le compilateur si tu as ne serait-ce qu'un constructeur)
le constructeur par copie
le destructeur
l'opérateur d'affectation
Tant que tu ne travailles pas avec des pointeurs, tu peux te dire que le comportement standard de ces différentes fonctions sera amplement suffisant.

Ainsi, le comportement standard du constructeur par copie sera de... copier les membres de ta classe "membre à membre". Il est donc tout à fait inutile de refaire toi-même ce que le compilateur fera tout aussi bien lui-même ;)

En outre, on peut estimer que ta classe uneDate a typiquement une sémantique de valeur: si tu modifie une de ses caractéristique, tu obtiens littéralement une autre date.

Il ne me semble donc pas vraiment opportun de prévoir le mutateur (void setDate(int, int, int) ), surtout sous cette forme (si tu avais prévu setJour, setMois et setAnnee, on aurait pu discuter ;))

Enfin, il y a un principe qu'il me semble important de rappeler: la loi demeter.

Ce principe, si une classe A (ici : unEvenement) utilise (en interne) un objet de la classe B (ici : uneDate), conseille de faire en sorte que l'utilisateur de la classe A n'ait même pas conscience du fait d'utiliser la classe B.

Ta classe unEvenement pourrait donc parfaitement prendre une forme proche de
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 class UnEvenement { private: UneDate date_; /* autres détails d'implémentation */ public: UnEvenement(int j, int m, int a /* autres paramètres */):date_(j,m,a) /* ...*/{} /* si, vraiment, on a besoin de disposer de la date * "depuis l'extérieur" */ int getJour() const{return date_.getJour();} int getMois() const{return date_.getMois();} int getAnnee() const{return date_.getAnnee();} };
De cette manière, si tu décide un jour de changer la manière dont la date est stockée dans ta classe événement, tu pourra le faire sans que le code qui utilise ta classe événement ne doive-être modifié d'aucune manière ;)

Enfin, il faut savoir que C++ fournit une classe spécialement prévue pour gérer les chaines de caractères: la classe std::string. Tu aurais vraiment intérêt à préférer l'utilisation de cette classe à celle des chaine "C style", car elle est beaucoup plus sécurisante et simple à utiliser ;)

22/04/2011, 17h01
bounadalvidal
Wow ! Merci tous pour vos réponses, c'est vraiment énorme !

Bon voilà :
Oussapik, voilà mon programme test :
Code:

1 2 3 4 5 uneDate date(1,1,2009); char * chaine = "voila"; unEvenement E(d,chaine); E.afficheToi();
(sinon tant que j'y suis, t'as raison koala01, le compilateur me renvoie une erreur de cast (conversion), ça marche parfaitement avec String, je voulais juste faire ça pour l'exercice, question de voir quels éventuels problèmes j'aurais...)

Aux quatre éléments créés automatiquement par une classe, == est à rajouter, non ?

Les setters sont bons, mais vraiment consommateurs de temps d'exécution...

Je retiendrais cette loi de Demeter :) !

Encore, merci tous ;) !
23/04/2011, 18h14
Invité
Non, l'operateur d'égalité n'est jamais défini par défaut :
Code:

1 2 3 4 5 6 class Test {}; //... Test t1, t2; t1 == t2; // ko
Aussi, fais attention lorsque tu utilise des chaines litterales (c'est à dire écrite en dure dans ton programme) : elles sont de type char const* et non char*
24/04/2011, 11h35
bounadalvidal
Citation:
Envoyé par Joe Dralliam

Non, l'operateur d'égalité n'est jamais défini par défaut :

Code:

1 2 3 4 5 6 class Test {}; //... Test t1, t2; t1 == t2; // ko

Aussi, fais attention lorsque tu utilise des chaines litterales (c'est à dire écrite en dure dans ton programme) : elles sont de type char const* et non char*
t1==t2 ; n'a pas de sens, mais par exemple if(t1==t2) peut être évaluée, non ? Bref faudrait que je fasse un petit programme de test :D ! Merci en tout cas !
24/04/2011, 15h06
Invité

Bah si t1==t2 peut être évalué alors if(t1==t2) peut aussi l'être... à condition que l'operateur respecte sa sémantique originale !
27/04/2011, 10h38
koala01

Citation:

Envoyé par bounadalvidal

Aux quatre éléments créés automatiquement par une classe, == est à rajouter, non ?

Pas forcément...

l'opérateur == (tout comme l'opérateur < ) ne sont nécessaires que si tu souhaite pouvoir trier tes objets ou les retrouver.