Petit probleme POO ^^

Bonjour,

J'expose mon probleme:

J'aimerai que la classe B puisse changer la valeur de Allume via void allumer(); appartenant à A.
Or, Le programme se compile mais ne change pas la valeur de allume.

Quelqun pourrait il maider s'il vous plait?

Merci :)


Voici 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 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56

#include<iostream>   using namespace std;   class A{     bool allume;   public:   A(){allume = false;} A(bool a){allume=a;} ~A(){}   void allumer(){allume = true;}   void afficher(){ if (allume == true) cout << "allumer" << endl; else if (allume == false) cout << "Eteind" << endl; }     };     class B{     public:   B(){} ~B(){}   void modifierA(A c){ c.allumer(); }   };       int main(){   A a; a.afficher(); // AFFICHE ETEIND       B b; b.modifierA(a); a.afficher(); //AFFICHE ETEIND ET NON ALLUME   cout << endl;   }

---

Code:

---

1 2 3 4 5 6

void modifierA(A c){ c.allumer(); }   A a; modifierA(a)

---

tu copie a dans c et tu change c. a n'est pas modifié :cry:

Code:

---

1 2 3 4 5 6

void modifierA(A &c){ c.allumer(); }   A a; modifierA(a)

---

tu explique au compilot que a et c sont la même instance et tu change c donc a
:D

voir les notions de passage de paramètres par adresse, valeur, référence :-)

Je vous remercie, ça marche impec ^^

Salut,

Quelques remarques au passage:

Le C++ autorise le fait de fournir une valeur par défaut, sous certaines conditions, aux arguments passés aux fonction.

Tu pourrais donc très bien te contenter d'un seul constructeur pour A, qui prendrait la forme de

Code:

---

1 2 3 4 5 6

class A { public: A(bool a=false); /* le reste*/ };

---

L'avantage étant que, que tu crées un objet de type A sous la forme de

Code:

---

A obj;

---

ou sous celle de

Code:

---

1 2	A obj(true); A obj2(false);

---

cela fonctionnera toujours, et t'évite d'avoir à coder un constructeur "par défaut" en plus ;)

La deuxième remarque concerne également le constructeur:

Il est préférable, autant que faire se peut, d'avoir recours aux listes d'initialisation dans les constructeurs.

Cela donnerait, toujours pour la classe A, un implémentation sous la forme de

Code:

---

A::A(bool a):alume(a){}

---

Si tu le souhaites, on se fera un plaisir de justifier le point de vue ;)

La troisième remarque concerne ta méthode Afficher():

allume est un booléen, ce qui signifie qu'il ne peut avoir que deux valeur: vrai (true) ou faux (false)...

Du coup, et c'est fatal, si allume ne vaut pas "vrai" (true) il vaut... "false" :roll:

Il est donc tout à fait inutile de faire un else if(condition inverse) dans le cadre de l'exemple présenté.

Le code

Code:

---

1 2 3 4 5 6 7

void afficher() { if (allume == true) cout << "allumer" << endl; else cout << "Eteind" << endl; }

---

La dernière remarque (pour l'instant du moins) concerne la "manière d'écrire le code"...

Il est primordial de garder dés le départ en tête le fait qu'un code sera bien plus souvent lu qu'il n'est écrit.

Le code écrit ou modifié une fois sera peut être lu 20, 30 ou 150 fois avant d'être modifié une nouvelle fois (surtout si tu le présente sur un forum :D)

Même si tu garde jalousement ton code "pour toi" et qu'il te paraît limpide au moment où tu l'écris, il peut te paraître beaucoup plus nébuleux quelques jours (mois/années) plus tard, quand tu voudra le relire, en ayant peut être oublié jusqu'à la logique que tu avais décidé de suivre :roll... Et les raisons qui te feraient revenir sur un code après l'avoir laissé "en l'état" sont nombreuses et variées ;)

Quitte donc à "perdre" une seconde lors de l'écriture (et encore, si tu ne tapes pas à deux doigts en cherchant la lettre suivante à chaque fois, ce n'est même pas une seconde de perdue :D) il faut absolument veiller à ce que le code reste lisible le plus naturellement possible (ce qui est écrit étant déjà parfois suffisemment incompréhensible).

Afin de s'assurer qu'un code sera facile à lire (et donc "plus facile" à comprendre), il faut donc s'astreindre à une politique de "mise en forme" du texte drastique:

• un système d'indentation cohérent tout au long du projet
• le fait de mettre une instruction/déclaration par ligne

sont déjà en partie suffisants.
En effet, l'exécutable créé sera identique pour une fonction écrite sous la forme de

Code:

---

1 2 3 4 5 6 7

void Afficher() { if (allume) cout<<"allume"<<endl; else cout<<"eteind"<<endl; }

---

que sous la forme de

Code:

---

1 2 3 4 5

void Afficher() { if (allume) cout<<"allume"<<endl; else cout<<"eteind"<<endl; }

---

ou même sous la forme de

Code:

---

void Afficher(){if (allume) cout<<"allume"<<endl; else cout<<"eteind"<<endl;}

---

La seule "différence", mais de taille, tenant dans le fait que la première version sera bien plus facile à lire que la deuxième et que la troisième devient carrément illisible... Et encore, la fonction est simple dans l'exemple donné :roll:

De la même manière, il faut savoir que, si le fait "d'aérer" un peu son code (en laissant une ligne vide de temps en temps) permet d'améliorer la lisibilité, le fait de laisser trop de lignes vides va au contraire la détériorer très fortement :P

A méditer :D

Citation:

---

Envoyé par koala01

Code:

---

1 2 3 4 5

void Afficher() { if (allume) cout<<"allume"<<endl; else cout<<"eteind"<<endl; }

---

ou même sous la forme de

Code:

---

void Afficher(){if (allume) cout<<"allume"<<endl; else cout<<"eteind"<<endl;}

---

---

et que dire de

Code:

---

void Afficher(){cout<< (allume) ? "allume" : "eteind"<<endl;

---

Personnellement j'aime bien cette ecriture :roll:.

Comme j'ai déjà justifié ma position vis à vis des raccourcis permis par le langage, je me contenterai de la réponse "abrégée"

• Oui si c'est indispensable
• *eventuellement* si c'est facultatif sans détériorer la lisibilité
• non si la lisibilité en souffre de trop et qu'il y a moyen de faire autrement