Salut,
Heuu, à vrai dire, je serais vraiment étonné que, tel quel, ton code fonctionne parce que, en dehors de toute précision contraire (ce qui est le cas tel que tu nous le présente ;) ), les membres et fonctions membres d'une classe ont une accessibilité par défaut à private, et ne sont donc accessibles qu'aux fonctions membres de la classe elle-même!!!
De plus, on préfère éviter le recours à des fonctions de type "init", parce que l'on préfère utiliser un mécanisme nommé "RAII" (Ressource Aquizition Is Initialization) en implémentant une fonciton particulière qui sera d'office appelée lorsque l'on crée une nouvelle instance de la classe et qui s'appelle le "constructeur".
Ainsi, ta classe Rectangle devrait plutôt ressembler à quelque chose comme
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
| class Rectangle
{
public: // si on ne ne le précise pas, tout est dans la visibilité private,
// et la classe devient inutilisable
/* le constructeur, prend les deux valeurs qui nous intéressent à
* savoir la longueur et la largeur
*/
Rectangle(float longueur, float largueur):
long(longueur),larg(largeur) // ceci s'appelle une liste d'initialisation
{
}
float perimetre() const /* précise que cette fonction s'engage à ne
* pas modifier l'objet au départ duquel elle est appelée
* Cela participe au respect de la "const-correctness"
*/
{
return (long+larg)*2;
}
void affich() const /* idem */
{
std::cout<<"longueur :"<<long<<std::endl
<<"largeur : "<<larg<< std::endl
<<"perimetre : "<<perimetr()<<std::endl;
}
private:
float long;
float larg;
}; |
et son utilisation deviendrait alors proche de
Code:
1
2
3
4
5
6
| int main()
{
rectangle r(2,3);
r.affich();
return 0;
} |
Le principe que l'on appelle "const-correctness" conseille, tout simplement, de préciser qu'une fonction qui ne modifie pas l'objet en cours (comme c'est le cas de perimetre() et de affiche(), mais comme ce n'était pas le cas de ta fonction init() )s'engage à... ne pas modifier l'objet en question.
Cela a son importance pour la simple et bonne raison que l'on va parfois devoir travailler avec des objets "constants" (des objets dont on ne veut absolument pas qu'ils soient modifiés durant le traitement qu'ils subissent), et que, dans de telles conditions, seules les fonctions qui se seront engagées à ne pas modifier les objet pourront être appelées.
Dans de telles circonstances, tu pourras danser sur ta tête, le compilateur sera décidément beaucoup plus buté que toi, et refusera purement et simplement que tu tentes d'utiliser une fonction non constante depuis un objet constant ;)
Finalement, le fait de déclarer constant tout ce qui n'a pas vocation à être modifié ou à modifier l'objet au départ duquel la fonction est appelée t'évitera bien des soucis suite à des modifications involontaires, appliquées par des fonctions qui seraient appelées par une fonction à laquelle tu aurais recours ;)
