Discussion :

[elmcherqui]

bonjour,

je voudrais savoir si le mot cle const utilise dans les methodes de classe est necessaire ou facultatif au bon fonctionnement de celle ci .

ex:

Code :

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

1
2
 
Nom_de_classe operator+(const Nom_de_classe &)

est ce que le mot cle const est necessaire ?

voila j'espere avoir ete claire dans ma question

[zouip]

Ce n'est pas une obligation mais c'est plus safe car ça t'oblige à ne pas modifier le deuxième opérande. Lors de l'utilisation de l'opérateur +, on ne s'attend pas à ce que la deuxième opérande soit modifiée.

[babar63]

Ce n'est pas une obligation mais c'est plus safe car ça t'oblige à ne pas modifier le deuxième opérande

Pas forcément, ici on peut modifier la variable passée en paramètre sans souci :

Code :

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

Nom_de_classe operator+(Nom_de_classe)

Pour simplifier :

Code :

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

1
2
3
Nom_de_classe operator+(Nom_de_classe c);             // Passage par recopie : [in]
Nom_de_classe operator+(Nom_de_classe &c);            // Passage par référence : [in] et/ou [out]
Nom_de_classe operator+(const Nom_de_classe &c);      // Passage par référence constante : [in]

[zouip]

Pas forcément, ici on peut modifier la variable passée en paramètre sans souci :

Code :

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

Nom_de_classe operator+(Nom_de_classe)

Justement, là tu n'a pas mis le mot clef const dans le passage par référence...

[babar63]

est ce que le mot cle const est necessaire ?

Ce n'est pas une obligation mais c'est plus safe

Ce que je voulais dire c'est qu'on est pas obligé d'utiliser const pour rester "safe", on peut aussi passé le paramètre par recopie... il faut juste faire la distinction entre les trois cas de figures :
Pour les types prédéfinis il est "préférable" de passer par recopie.
Sinon il est "préférable" de passer par référence et dans ce cas si on ne souhaite pas modifier le paramètre alors il faut utiliser const

[zouip]

Okay on est sur la même longueur d'onde

[Garulfo]

Ce que je voulais dire c'est qu'on est pas obligé d'utiliser const pour rester "safe", on peut aussi passé le paramètre par recopie... il faut juste faire la distinction entre les trois cas de figures :
Pour les types prédéfinis il est "préférable" de passer par recopie.
Sinon il est "préférable" de passer par référence et dans ce cas si on ne souhaite pas modifier le paramètre alors il faut utiliser const

Mais effectuer un passage par valeur peut poser un sérieux problème de performance. En fait l'idéal serait de toujours faire un passage par référence constante dans le cas général et de ne faire des copies que dans des cas contrôlés.

Le const assure qu'on ne change pas la valeur à l'intérieur de la fonction de manière statique. C'est donc mieux encore que le passage par valeur d'après moi (comprendre « plus sûr »).

[babar63]

Mais effectuer un passage par valeur peut poser un sérieux problème de performance. En fait l'idéal serait de toujours faire un passage par référence constante dans le cas général et de ne faire des copies que dans des cas contrôlés

Pourquoi toujours? Passer des int, float,... par références améliore les performances? Pour ma part j'utilise ce système excpeté pour quelques éxceptions très particulières :

Code :

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

1
2
3
Nom_de_classe operator+(Nom_de_classe c);             // Passage par recopie [in], type prédéfini
Nom_de_classe operator+(Nom_de_classe &c);            // Passage par référence : [out] ou [in]/[out], type personnalisé
Nom_de_classe operator+(const Nom_de_classe &c);      // Passage par référence constante : [in] type personnalisé

Ca ne couvre pas tous les cas mais les plus communs je pense...

Le const assure qu'on ne change pas la valeur à l'intérieur de la fonction de manière statique. C'est donc mieux encore que le passage par valeur d'après moi (comprendre « plus sûr »)

Pour moi le const est utilisé pour associer une propriété à une donnée et non comme un moyen plus sûr, il permet une meilleur lecture du code, (d'ailleurs si je ne me trompe pas le compilateur apprécie aussi ) ... Mais ça c'est une question de point de vue je suppose

[zouip]

Pour moi le const est utilisé pour associer une propriété à une donnée et non comme un moyen plus sûr, il permet une meilleur lecture du code, (d'ailleurs si je ne me trompe pas le compilateur apprécie aussi ) ... Mais ça c'est une question de point de vue je suppose

Quand je fais un const pour un passage par référence, c'est toujours dans un soucis de sécurité. Même si le code de ta fonction est simple, il peut modifier la référence sans que tu t'en rende compte au premier abord, ce qui peut avoir des répercussions désastreuses sur le reste du programme. Mettre ce mot clef const, c'est se forcer à respecter les règles qu'on s'est soit même imposé, ça évite aussi de passer des heures à débugger

[NiamorH]

Bon il y a deux débat différents.

Pour ce qui est du passage par valeur Vs référence constante :
On se trouve dans une situation où l'on a besoin d'un objet en lecture, sans qu'il se retrouve modifié après l'appel de la fonction. Il a déjà été dit que les types dont la taille est supérieure à celle d'un pointeur au moment de la compilation doivent préférer le passage par référence constante. Tous les autres (la plupart des types primitifs en l'occurence) doivent préférer le passage par valeur. La raison est simple : il est parfois plus rapide de recopier l'adresse d'un objet plutôt que l'objet lui même, par contre, si l'on passait un int par référence constante dans un système qui utilise les int pour représenter les pointeurs, on aurait aucun gain ni perte pour la recopie, mais lors de l'accès, il y aurait toujours une indirection du fait de manipuler une adresse, donc moins intéressant.

Pour le mot clef const :
On l'utilise simplement lorsque, après un appel à la fonction, il ne serait pas logique de se retrouver avec un objet dont l'état a changé, point. Evidemment c'est plus sûr dans le sens où la personne qui écrit le corps de la fonction est limitée aux appels des méthodes déclarées const sur l'objet. Malheureusement, il n'existe aucune véritable garantie que l'objet n'est pas été modifié par la fonction (const_cast ou autre). De ce fait, le compliateur n'optimise rien du tout (désolé babar63).
C'est tout à fait vrai que le mot clef const améliore la lecture. Pour l'utilisateur de la fonction, il donne déjà des indications sur ce que fais la fonction (je vais modifier cet objet, pas celui là etc.).

Le mot clef n'est pas nécessaire pour un passage par valeur. L'objet passé est un temporaire, détruit après l'appel. Il peut donc être modifié librement.

[zais_ethael]

Un petit détail au passage sans trop m'immiscer dans le débat:
dans le cas présenté au premier post, l'opérateur + devrait être lui aussi déclaré const, parce que c'est le fonctionnement attendu dans ce type d'opérateur, il ne devrait jamais modifier ni l'instance à gauche ni l'instance à droite de l'opérateur et se contenter de renvoyer une valeur.

[NiamorH]

Il devrait ne pas être membre de la classe surtout...

[zouip]

Effectivement, dans le cas présenté au premier post, il aurait été préférable de faire une surchage externe de l'opérateur +

Exemple:

Code :

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

1
2
3
4
5
6
7
8
class A {
     friend A operator+(const A&, const A&);
     /* ... */
};
 
A operator+(const A& operande_a, const A& operande_b){
   /* ... */
}

[Alp]

En effet. Pour la plupart des opérateurs binaires (tous ?), il vaut mieux le définir à l'extérieur de la classe concernée.

Pourquoi ?

Parce que dans la plupart des cas, il n'y a aucune raison de privilégier l'une ou l'autre des opérandes.

C'est à dire :

Code :

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

a + b

doit plutôt s'interpréter comme

Code :

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

operator+(a,b)

que comme

Code :

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

a.operator+(b)

[zais_ethael]

Bah je ne vois pas pourquoi, si l'opérateur entre dans la conception de la classe ça fonctionne aussi bien, et c'est tout aussi clair.

[zouip]

Ca fonctionne tout aussi bien, mais ça n'est certainement pas plus clair.
L'opérateur + est en théorie symétrique, ce qui est incohérent avec la surcharge interne de cet opérateur.

[Alp]

C'est ce que j'ai essayé de dire, oui, désolé si je n'ai pas été clair.

[koala01]

Bah je ne vois pas pourquoi, si l'opérateur entre dans la conception de la classe ça fonctionne aussi bien, et c'est tout aussi clair.

Simplement parce que l'opérateur intervient généralement (ou en tout cas peut intervenir) dans la partie droite d'une expression plus complexe qui a pour but d'affecter la valeur résultante à une troisième variable, sans pour autant vouloir modifier le premier opérande.

Les opérateurs mathématiques sont en effet susceptibles d'intervenir dans des expressions du genre de

Code :

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

1
2
3
4
c = a + b ;
c = a - b ;
c = a * b;
c = a / b;

alors que tu veux peut être garder la valeur originale de a

Si tu souhaite modifier effectivement la valeur de a, le fait d'avoir l'opérateur défini à l'extérieur de la classe ne posera pas de problème d'écrire

Code :

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

1
2
3
4
a = a + b;
a = a - b;
a = a * b;
a = a / b;

mais, tu préféreras sans doute utiliser les opérateurs +=, -=,*= ou /=, qui seront, eux, défini au sein de la classe

[zais_ethael]

Si je me souviens de mes vieux cours mon prof nous avait simplement expliqué que déclarer un opérateur dans la classe obligeait à placer la seconde opérande à droite de l'instance courante, ça m'a largement suffit pour comprendre le fonctionnement et je ne suis jamais étonné du comportement d'un opérateur. Il ne faut pas être un gourou en la matière pour ne jamais faire d'erreur d'interprétation du code.
Aussi je suis un peu étonné de vous voir prêcher comme un vérité quelque chose qui n'est jamais que... très subjectif.
Par contre vous avez complètement éclipsés ma remarque sur la constance de l'opérande de gauche ce qui est tout de même un peu plus important (car ça ça change la sémantique).

[Médinoc]

Attention, un opérateur + ne doit pas modifier le membre de gauche.
Donc, si on en fait une fonction membre:

Code C++ :

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

1
2
3
4
5
6
7
8
9
10
11
class A
{
public:
	...
	A operator+ (A const &right) const;
};

A A::operator+ (A const &right) const
{
	...
}