Salut à tous,
vous vous demandez ce que sont les accesseurs et les mutateurs ? Ce sont en fait des fonctions membres d'une classe, ceux-là ont une fonction spéciale, c'st de retourner ou de modifier la valeur d'une variable membre de la classe. Voici une explication plus approfondie.
Que sont-ils ?
Un accesseur est une fonction qui retourner la valeur d'une variable membre de la classe, tandis qu'un mutateur ou modifieur est une fonction qui permet de modifier la valeur de cette variable membre. Lorsqu'un utilisateur doit passer par des accesseur / mutateurs au ld'accéder directement aux données internes, cela renforce la sécurité (peut éviter les trous de mémoires si vous allouez bien, et que vous vérifiez certaines choses...).
Voici un exemple:
class CPerson
{
public:
// accesseur : renvoie le nom
// notez le const
const std::string & GetName() const
{
return this->name;
}
// mutateur : change le nom
void SetName( const std::string & NewName )
{
this->name = NewName;
}
private:
std::string name; // nom de la personne
};
On voit donc que GetName renvoi la valeur de name, alors que SetName la modifie, cela veut dire que GetName est un accesseur et SetName un mutateur modifieur.
L'exemple montre bien qu'il est courant d'utiliser les préfixe Get pour les accesseur et Set pour les mutateurs / modifieur. C'est d'ailleurs pour cela qu'on appelle les accesseurs des getter et les mutateurs des setter. Vu que les accesseurs ne modifient pas la valeur du membre, mais permettent un accès en lecture seule au membre de la classe, il est utile de les rendre constante, vu qu'elle ne modifie pas de valeur dans la classe... (Cela est un peu plus rapide).
J'espère que cette brève explication vous aura permis de comprendre ce que sont les accesseurs / mutateurs et que vous vous habituerez à les utiliser, car je les trouve moi aussi très sympathiques à l'utilisation.
Merci de laisser ce post sans commentaire, il appartient à la FAQ CC++. Si vous avez encore des questions postez un nouveau Topic.
On peut aussi compléter en indiquant que les mutateurs permettent de vérifier que les données sont bien correctes (par exemple sont bien dans la plage de valeurs attendue ou correspondent à un certains format). Cette phase de validation des données peut être trs complexe si on a des contraintes du style : on ne veut pas que dans une liste 2 personnes portent le même nom et le même prénom.
On peut également ne donner un accès qu'en lecture à certaines variables ce qui contribue à garantir l'intégrité des données.On écrira alors uniquement un accesseur sans mutateur. On peut donc afficher cette donnée mais pas la modifier.
Personnellement je conseille :
de mettre toutes les données d'une classe en private ou protected et de n'y accéder qu'au travers des accesseurs et mutateurs.
sebsheep dit : Un autre avantage des mutateurs/accesseurs par rapport à l'acces direct via les membres.
Imaginons que je crée une classe de position :
class position
{
public :
double x,y;
//d'autres fonctions...
}
J'ai de la chance, ma classe marche d'enfer et tout le monde l'utiliser pour faire ses programmes. Seulement voilà, je me rends compte 1 mois apres la sortie mondiale de ma classe, que reperer les choses en polaires serait beaucoup plus pratique et rapide dans les calculs... donc je change ma classe :
class position
{
public :
double rho,teta;
//d'autres fonctions ...
}
oui tres bien... mais comment vont faire les utilisateurs de ma classe "position" pour profiter des améliorations? Ils devront tout recoder vu qu'ils accedaient directement aux membres... C'est quand même un peu embetant non?
Si j'avais mis les membres en private avec des accesseurs, cela n'arriverai pas. En effet, il y aura toujours une méthode Get_x(), il suffira juste que je modifie cette fonction afin de faire la conversion entre les 2 et le tour est joué. Et donc pas besoin à l'utilisateur de la classe de retoucher une seule ligne de code, juste recompiler!
je rajoute juste un point de vue:
Il ne faut pas trop abuser de Set..() et Get...() sinon autant mettre les données publiques dans la class. L'inconvénient des getters et setters est qu'ils ont tendance chez certaines personnes à détruire intégralement l'encapsulation.
Pour éviter cela, plutôt qu'appeler des setters/getters, on peut dans pas mal de cas appeler des fonctions de traitement.
Par exemple au lieu de faire des Compte.setNom() Compte.setPass() Compte.setAddresse()... Il vaut mieux utiliser un Compte.Init() qui initialise tout et fais les vérifications nécessaires !
__________________________
............ Curtis: RTS 3D .............. ......
........... TeamMoteurProg...........