Discussion :

[r0d]

(Je ne fais que l'intermédiaire de cette discussion, juste un peu mise en forme).

Effectivement je pense que l'on pourrait remplacer cette entrée: Pourquoi certaines fonctions membres possèdent le mot clé const après leur nom ?
par quelque chose comme:

Le mot-clé const

const se réfère toujours à ce qui est a gauche, sauf si c'est le premier terme, dans ce cas ca se réfère a ce qui est à droite

Les 2 lignes suivantes sont donc équivalentes:

Code :

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

type const maFonction();

Code :

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

const type maFonction();

elles indiquent que la valeur de retour est de type "type" mais constante.

Idem pour les pointeurs:

Code :

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

type const * maFonction();

ici, on indique qu'il s'agit d'un pointeur sur des type const.

Code :

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

type* const maFonction();

ici, un pointeur constant sur type que l'on peut modifier.

Code :

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

type const * const * maFonction();

ici, un pointeur sur un pointeur const qui pointe sur des type const.

Si c'est a droite d'une méthode :

Code :

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

1
2
3
4
class A
{
    type maFonction() const;
};

cela signifie qu'au sein de la méthode, this, au lieu d'être un pointeur sur A, sera un pointeur sur A const, donc les champs seront const.

merci screetch

[Luc Hermitte]

Droite-gauche, berk! (je fais parti de ces gens qu'il ne faut surtout pas copiloter en voiture avec un simple droite/gauche -- je déteste bien les dénominations officielles que sont rvalue/lvalue)
Je préfère ma formulation (bizarre, n'est-ce pas?) http://cpp.developpez.com/faq/cpp/?p...har_const_char
Par contre, il manque effectivement les cas "T*const" et "T const * const", et des liens vers les entrées sur "T C::f() const" et "T const f()".
La dernière nécessitant d'expliquer le pourquoi : là vous ne parler que de syntaxe, et ceci est le piège dans lequel tombe la majorité des formateurs C++ -- cf GOTW/MEC++? pour le pourquoi/comment.

BTW, le titre n'est pas une question -- vous avez une tendance à jouer à geopardy en ce moment, et je ne trouve pas ça très FAQ. (j'avais déjà signalé ma frilosité avec certains nouveaux titres de Questions de FAQs)

PS: Attention! Un autre fil sur const avec la prose de koala dedans a été ouvert la semaine dernière.

[JolyLoic]

BTW, le titre n'est pas une question -- vous avez une tendance à jouer à geopardy en ce moment, et je ne trouve pas ça très FAQ. (j'avais déjà signalé ma frilosité avec certains nouveaux titres de Questions de FAQs)

Je suis assez d'accord avec ce point de vue. Et ce n'est pas uniquement affaire de formulation. Pour moi, la FAQ n'est pas vraiment sensée être un cours, mais plutôt un truc dans lequel on peut aller à la pêche aux infos de manière ponctuelle, pour répondre à une question précise. Elle n'est pas sensée attirer le même genre de personne (ou du moins pas au même moment) qu'un cours construit, et j'ai peur qu'elle perde son efficacité si elle perd sa concision, son esprit d'à propos.

[nikko34]

Surtout qu'on s'addresse surtout (j'imagine) à des gens ayant peu d'expérience et pas forcément un background théorique sur la programmation.

Peut-être pas exhaustif, mais un simple:

Quels sont les différentes significations du mot-clé "const" dans la signature d'une méthode ( fonction? ) ?

const std::string & MaClasse::maFonction( const std::string & parametre ) const;

const std::string & MaClasse::maFonction( const std::string & parametre ) const;
le type de retour est constant

const std::string & MaClasse::maFonction( const std::string & parametre ) const;
le paramètre est constant

const std::string & MaClasse::maFonction( const std::string & parametre ) const;
la méthode ne modifie pas l'objet. On peut utiliser les méthodes const d'un objet const.

enfin quelque chose dans cet esprit?

[koala01]

Salut,

Droite-gauche, berk! (je fais parti de ces gens qu'il ne faut surtout pas copiloter en voiture avec un simple droite/gauche -- je déteste bien les dénominations officielles que sont rvalue/lvalue)

On peut se demander si précédent et suivant (ou des termes similaires) sont réellement mieux ou non...

Ici, il s'agit réellement de parler de la position d'un terme par rapport à d'autres

Quoi qu'il en soit, une homogénéisation des termes au travers de la FAQ ne serait sans doute pas un luxe, le tout étant de décider si l'on préfère gauche /droite ou précédent / suivant

(la majorité l'emporterait sur ce coup )

Je préfère ma formulation (bizarre, n'est-ce pas?) http://cpp.developpez.com/faq/cpp/?p...har_const_char

Pas vraiment, on a tous notre petite fierté

Par contre, il manque effectivement les cas "T*const" et "T const * const", et des liens vers les entrées sur "T C::f() const" et "T const f()".

Il est vrai qu'il n'existe qu'une question à l'heure actuelle proche de ce problème et qu'elle traite des char

J'ai fais une proposition plus générique à intégrer

La dernière nécessitant d'expliquer le pourquoi : là vous ne parler que de syntaxe, et ceci est le piège dans lequel tombe la majorité des formateurs C++ -- cf GOTW/MEC++? pour le pourquoi/comment.

Je suis assez d'accord avec ce point de vue. Et ce n'est pas uniquement affaire de formulation. Pour moi, la FAQ n'est pas vraiment sensée être un cours, mais plutôt un truc dans lequel on peut aller à la pêche aux infos de manière ponctuelle, pour répondre à une question précise. Elle n'est pas sensée attirer le même genre de personne (ou du moins pas au même moment) qu'un cours construit, et j'ai peur qu'elle perde son efficacité si elle perd sa concision, son esprit d'à propos.

Je rejoins l'avis de loic...

Le but de la FAQ est beaucoup plus axé sur le comment que sur le pourquoi, même s'il peut parfois être intéressant de parler du pourquoi, ce doit être évalué au cas par cas

BTW, le titre n'est pas une question -- vous avez une tendance à jouer à geopardy en ce moment, et je ne trouve pas ça très FAQ. (j'avais déjà signalé ma frilosité avec certains nouveaux titres de Questions de FAQs)

Sur ce point, nous sommes d'accord

PS: Attention! Un autre fil sur const avec la prose de koala dedans a été ouvert la semaine dernière.

Prose qui a été fait d'un jet suite à une proposition de question sur les références, en réalité

Mais il y a tellement de choses à dire sur le mot clé const qu'il me semble indispensable de faire plusieurs questions réponses, parmi lesquelles:

• à quoi sert-il
• quelle est sa signification dans tel et tel cas
• ...

L'un dans l'autre, il faudrait prévoir carrément quatre à cinq questions pour avoir une vue générale de son utilité et de son emploi

Surtout qu'on s'addresse surtout (j'imagine) à des gens ayant peu d'expérience et pas forcément un background théorique sur la programmation.

Tout à fait...

Il me semble même qu'il y a, quelque part, une prose qui indique carrément que la FAQ peut aussi servir à des décideurs RH ou autres, n'ayant aucune connaissance dans le domaine, afin de pouvoir tester "facilement" les postulants...

Mais cette prose a peut être été retirée depuis

Peut-être pas exhaustif, mais un simple:
<sniped code>
enfin quelque chose dans cet esprit?

En fait, comme je viens de le dire, je verrais d'avantage une série de Q/R simple et clairement spécifique.

Ce pourrait être:
Que signifie le mot clé const?

Le mot clé const nous permet d'indiquer que l'objet sur lequel nous travaillons n'a pas vocation à être modifié (qu'il est "en lecture seule").

De ce fait, les seules opérations qui seront admises sur cet objets seront celles qui ne tentent en aucun cas de le modifier.

quelle est la différence entre const Type et Type const

Il n'y en a pas.

La règle indique que le mot clé const s'appplique à ce qui le précède directement sauf si c'est le premier terme rencontré.

Dans ce cas, le mot clé const s'applique au terme qui le suit directement.

Ainsi, les deux écritures suivantes sont strictement identiques, à ceci près que la première suit la règle générale et que la seconde suit la règle particulière:

Code :

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

1
2
3
 
int const regleGenerale= 4;
const int regleParticuliere = 4;

Que signifie le mot clé const en fin de prototype de fonction

Le mot clé const peut se trouver en fin de prototype de fonction uniquement lorsque l'on déclare ou que l'on définit une fonction membre d'une classe ou d'une structure.

Il indique alors que la fonction s'engage à ne pas modifier l'objet au départ duquel elle est appelée.

Seules les fonctions déclarées constantes peuvent être appelées au départ d'objets qui sont eux-même déclarés constants.

Peut on invoquer une fonction constante sur un objet non constant?

Oui.

Lorsque l'on déclare un objet comme étant constant, on ne fait que rajouter des restrictions quant à son utilisation (en empêchant qu'il soit modifié).

Il est donc tout à fait possible d'invoquer une fonction membre constante au départ d'un objet non constant, par contre, il est impossible d'invoquer une fonction membre non constante au départ d'un objet constant, car les restrictions ne sont plus respectée.

Ainsi, si nous avons une classe proche de

Code :

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

1
2
3
4
5
6
class MaClas
{
    public:
       void foo() const;
       void bar();
};

nous pouvons invoquer tout aussi bien foo que bar au départ d'un objet non constant, par contre, seul l'appel de foo sera autorisé au départ d'un objet constant.

Qu'appelle-t-on la const-correctness?

Ce terme que nous pourrions traduire par "l'usage correct de la constance" regroupe l'ensemble des techniques mises en oeuvre afin de s'assurer qu'un objet qui n'a pas vocation à être modifié ne le soit jamais.

Il est en effet préférable de travailler avec un objet constant chaque fois que l'objet en question ne doit pas être modifié, et ce, même si l'objet en question est à la base susceptible de l'être.

Nous éviterons ainsi de nombreux effets de bords qui peuvent avoir des effets extrêmement déplaisants.

Que signifient les différents const dans Type1 const & MaClass::foo(Type2 const & t) const ?

Le premier usage de const (Type1 const &) indique que l'objet de type Type1 qui sera renvoyé (sous la forme d'une référence) par la fonction n'aura pas vocation à être modifié dans la fonction qui le récupère.
Le second usage du mot clé (Type2 const &) indique que l'objet de type Type2 passé par référence en paramètre de la fonction ne sera pas modifié par la fonction, ce qui permet le cas échéant de passer une variable temporaire à la fonction.
Le dernier usage du mot clé const indique que la fonction s'engage à ne pas modifier l'objet de type MaClass au départ duquel la fonction est appelée.

Dans le cas d'objets de type MaClass déclarés constants, seules les fonctions membres qui sont déclarée constantes par ce biais pourront être invoquées <lien vers "Que signifie le mot clé const en fin de prototype de fonction" >

Evidemment, ce ne sont ici que des premiers jets, susceptibles de modifications, et je n'ai absolument pas vérifié dans la FAQ si l'une ou l'autre de ces Q/R est déjà présente

Tout comme je ne garanti absolument pas que l'on ait abordé l'ensemble des problèmes qui concernent le mot clé const

[r0d]

Effectivement, je suis d'accord. const nécessite plusieurs entrées.

Personnellement, au plus je gagne en expérience, au plus ce mot-clé est important. Et, bon je n'ai pas les mots, mais ce qui est important dans ce mot-clé, c'est ce que l'on dit au développeur qui va utiliser note code (souvent c'est nous-même). Et comme tu disais, koala, dans un de tes posts que j'ai lu récemment, quelque chose comme: "peut-être que finalement, le plus important dans un code source, c'est que les développeurs qui le lirons puissent le comprendre, et ça c'est peut-être même plus important que ne serait-ce que ce code compile". 'fin c'était un truc du style, et moi, au plus ça va, au plus je suis d'accord avec ça.

D'où l'importance du const.

Enfin même, j'y vois un énorme "vecteur d'apprentissage". Je veux dire: la const-conformité est une notion que l'on peut comprendre sans connaitre rien du c++. Et si on l'applique dès le début, lorsqu'on crée par exemple une classe string, pour commencer, ben déjà le simple fait de déclarer const ce qui doit l'être et "non const" ce qui doit être "non const", c'est déjà un premier pas vers le graal: "un diagramme UML propre" :p

Enfin bon, tout ça pour dire que je suis d'accord avec ta proposition. Déjà une première entrée pour expliquer juste la sémantique de const, ça c'est dla balle (d'ailleurs, de façon générale, je trouve que l'on n'insiste pas assez sur la sémantique dans le "monde des développeurs", et pas uniquement en c++, loin de là).

Sinon,
sur le titre:
"Peut on invoquer une fonction constante au départ d'un objet non constant?"
Je propose:
"Peut on invoquer une fonction constante dans une fonction non constante?"

Dans l'entrée "Que signifie le mot clé const en fin de prototype de fonction"
Je propose d'ajouter une phrase, à la fin, du style: "il faut bien comprendre que le fait de déclarer une fonction comme constante à une signification. Prenons par exemple la classe matrice proposée par M. Cline, ch. 13.8, la même fonction (l'opérateur () (unsigned row, unsigned col)) n'a pas du tout le même sens s'il est déclaré en const ou pas const. Et si vous voulez pas du lien vers la FAQ de MC, ya du code à moi qui traine sur dvp où j'ai implémenté ça.

Mouais... je pense que je ferais mieux de m'arrêter là. Je sais pas, on verra demain s'il y a quelque chose à tirer de ce post

[koala01]

Effectivement, je suis d'accord. const nécessite plusieurs entrées.

Personnellement, au plus je gagne en expérience, au plus ce mot-clé est important. Et, bon je n'ai pas les mots, mais ce qui est important dans ce mot-clé, c'est ce que l'on dit au développeur qui va utiliser note code (souvent c'est nous-même). Et comme tu disais, koala, dans un de tes posts que j'ai lu récemment, quelque chose comme: "peut-être que finalement, le plus important dans un code source, c'est que les développeurs qui le lirons puissent le comprendre, et ça c'est peut-être même plus important que ne serait-ce que ce code compile". 'fin c'était un truc du style,

Mes termes exacts sont

A la limite, la première qualité d'un code, avant même de faire ce que l'on attend de lui, est d'être facilement compréhensible par celui qui le lit

Et je ne n'émet aucun doute sur le sujet

Mais l'idée y était

et moi, au plus ça va, au plus je suis d'accord avec ça.

Je crois que tout le monde finit tôt ou tard par être plus ou moins d'accord avec cela...

Il suffit, le plus souvent, que quelqu'un ait passé un quart d'heure à se gratter la tête en essayant de comprendre le sens d'un code pour qu'il prenne ce point de vue

D'où l'importance du const.

Enfin même, j'y vois un énorme "vecteur d'apprentissage". Je veux dire: la const-conformité est une notion que l'on peut comprendre sans connaitre rien du c++. Et si on l'applique dès le début, lorsqu'on crée par exemple une classe string, pour commencer, ben déjà le simple fait de déclarer const ce qui doit l'être et "non const" ce qui doit être "non const", c'est déjà un premier pas vers le graal: "un diagramme UML propre" :p

Enfin bon, tout ça pour dire que je suis d'accord avec ta proposition. Déjà une première entrée pour expliquer juste la sémantique de const, ça c'est dla balle (d'ailleurs, de façon générale, je trouve que l'on n'insiste pas assez sur la sémantique dans le "monde des développeurs", et pas uniquement en c++, loin de là).

Je ne peux qu'être d'accord avec toi...

Si tu savais le nombre de fois où je me suis "frité" avec quelqu'un parce que ce qu'il proposait était sémantiquement incorrect (souvent à propos de l'héritage public )

(au fait, merci pour le terme "const-conformité", on pourrait l'utiliser à la place de "l'usage correct de la constance" )

Sinon,
sur le titre:
"Peut on invoquer une fonction constante au départ d'un objet non constant?"
Je propose:
"Peut on invoquer une fonction constante dans une fonction non constante?"

Je ne sais pas...

Ce sur quoi je voulais insister est en fait qu'il est tout à fait possible d'avoir un code proche

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
class MaClass
{
    public:
        void foo() const; // fonction constante
        /*...*/
};
int main()
{
    MaClass c; // un objet non constant
    c.foo(); // appel d'une fonction constante au départ d'un objet non constant
    /*...*/
}

La (non) constance de la fonction dans laquelle on invoque la fonction constance a, finalement, beaucoup moins d'importance que la (non) constance de l'objet au départ duquel la fonction est appelée à mon sens

Mais je reste ouvert à toute proposition

Dans l'entrée "Que signifie le mot clé const en fin de prototype de fonction"
Je propose d'ajouter une phrase, à la fin, du style: "il faut bien comprendre que le fait de déclarer une fonction comme constante à une signification. Prenons par exemple la classe matrice proposée par M. Cline, ch. 13.8, la même fonction (l'opérateur () (unsigned row, unsigned col)) n'a pas du tout le même sens s'il est déclaré en const ou pas const. Et si vous voulez pas du lien vers la FAQ de MC, ya du code à moi qui traine sur dvp où j'ai implémenté ça.

Crois tu vraiment que ce soit indispensable

La deuxième ligne de l'entrée que je propose explique clairement le but et le sens du mot clé à cette place:

Il indique alors que la fonction s'engage à ne pas modifier l'objet au départ duquel elle est appelée.

On pourrait par contre insister sur le fait qu'il faut réfléchir sereinement à l'opportunité de déclarer une fonction membre constante, car ce n'est pas automatique

Mouais... je pense que je ferais mieux de m'arrêter là. Je sais pas, on verra demain s'il y a quelque chose à tirer de ce post

Tout avis est bon à prendre

[JulienDuSud]

Quid du mot clé mutable ?

Il faudrait à mon avis en parler dans la FAQ, à prévenir la sémantique et à en lister les conséquences, vu que c'est étroitement lié avec le mot clé const.

[screetch]

http://cpp.developpez.com/faq/index....on&r3=on&r4=on

[koala01]

Quid du mot clé mutable ?

Il faudrait à mon avis en parler dans la FAQ, à prévenir la sémantique et à en lister les conséquences, vu que c'est étroitement lié avec le mot clé const.

A vrai dire, j'y pensais effectivement en composant la prose que j'ai proposée

D'ailleurs, de manière générale, je me dis qu'il serait peut-être pas mal de rajouter une section complete à la FAQ qui traiterait des différents mot clés, et qui regrouperait, par exemple, static, extern, const, volatile, register, mutable, et j'en passe, afin de donner une idée claire de leur usage

Maintenant, je sais que j'ai tendance à être prolixe, mais n'hésitez pas, autant que vous êtes, à faire des propositions dans ce sens...

Même si ce n'est que la proposition d'une question pour laquelle vous avez du mal à "pondre" la réponse

[Luc Hermitte]

Le but de la FAQ est beaucoup plus axé sur le comment que sur le pourquoi, même s'il peut parfois être intéressant de parler du pourquoi, ce doit être évalué au cas par cas

Ce que disait Loic ne me contredit pas du tout. Si vous me le permettez, je vais interpréter ces propos à ma sauce (je ne dit pas que c'est ce qu'il pense).
Les cours de C++ parlent du comment, jamais du pourquoi. -- ça c'est ma vision : trop axé sur la syntaxe et pas assez sur les idiomes et leurs origines
La FAQ ne doit pas redonder un cours -- ce que dit Loic, et ma pensée initiale quand j'ai parlé de geopardy.
Le pourquoi étant ce que l'on ne trouve pas dans un cours, il aurait alors sa place dans une FAQ.
....
Reste à l'amener correctement pour que cela ne ressemble pas à série de questions de cours.


Sinon :
+1 à plein de questions différentes sur des points précis à chaque fois
++plein à tes formulations de Q/R qui me plaisent beaucoup.

Toutefois,
a- je n'ai pas vu abordé directement la dichotomie entre la constante sémantique-et-apparente et la constance syntaxique. Dichotomie à l'origine du mot clé mutable.

b- "quelle est la différence entre const Type et Type const"
Il faudrait rajouter un lien vers l'entrée de FAQ qui explique que Type peut être un "T*", un "T&", ... Et que "Type const" est un nouveau type que l'on peut décorer d'une nouvelle étoile, et rajouter un nouveau const derrière l'étoile, etc.
(je pense que l'on peut dire que l'on est parti pour nettoyer les anciennes entrées sur const)

c- il manquerait le cas: "T const f()" qui permet de miner le comportement des types primitifs : avec "int f()", on ne peut pas faire "v = f()+=42;". La situation n'est pas la même que celle du retour de "T const&" qui renvoit une référence vers un truc qui existe par ailleurs. Dans "T const", on renvoie par valeur un truc nouveau et temporaire.

d- On pourrait aussi l'évoquer l'intérêt des déclarations de variables locales const. A voir. Ce n'est pas une pratique fréquente, et donc une question qui pourrait l'être. Reste que c'est une pratique que je trouve de moins en moins idiote et que j'utilise de plus en plus souvent -- surtout dans les codes dont j'hérite de la maintenance.

sur le titre:
"Peut on invoquer une fonction constante au départ d'un objet non constant?"
Je propose:
"Peut on invoquer une fonction constante dans une fonction non constante?"

Attention, le sens n'est pas du tout le même. Effectivement, le titre ne sera pas immédiatement compréhensible d'un débutant, mais il est bien plus précis.
A la limite, on peut remplacer "au départ de" par "sur un".

[koala01]

Reste à l'amener correctement pour que cela ne ressemble pas à série de questions de cours.

Eventuellement, s'il est possible de le faire sans devoir écrire un roman (je garde ce plaisir pour mes interventions sur le forum )

++plein à tes formulations de Q/R qui me plaisent beaucoup.

Merci , ca me touche beaucoup, j'en ai presque la larme à l'oeil

(je pense que l'on peut dire que l'on est parti pour nettoyer les anciennes entrées sur const)

S'il apparait que c'est la moins mauvaise solution, ce sera effectivement le cas
[quote]Toutefois,
a- je n'ai pas vu abordé directement la dichotomie entre la constante sémantique-et-apparente et la constance syntaxique. Dichotomie à l'origine du mot clé mutable.

b- "quelle est la différence entre const Type et Type const"
Il faudrait rajouter un lien vers l'entrée de FAQ qui explique que Type peut être un "T*", un "T&", ... Et que "Type const" est un nouveau type que l'on peut décorer d'une nouvelle étoile, et rajouter un nouveau const derrière l'étoile, etc.
[QUOTE]De manière générale, les liens entre Q/R sont très intéressants, pas uniquement dans ce cas précis, et, si je ne l'ai pas indiqué, c'est sans doute simplement un oubli

c- il manquerait le cas: "T const f()" qui permet de miner le comportement des types primitifs : avec "int f()", on ne peut pas faire "v = f()+=42;". La situation n'est pas la même que celle du retour de "T const&" qui renvoit une référence vers un truc qui existe par ailleurs. Dans "T const", on renvoie par valeur un truc nouveau et temporaire.

d- On pourrait aussi l'évoquer l'intérêt des déclarations de variables locales const. A voir. Ce n'est pas une pratique fréquente, et donc une question qui pourrait l'être. Reste que c'est une pratique que je trouve de moins en moins idiote et que j'utilise de plus en plus souvent -- surtout dans les codes dont j'hérite de la maintenance.

Il parait (et j'en suis convaincu) que 50% de la solution se trouve dans la manière d'énoncer le problème...

Trouvons donc une expression correcte pour énoncer ces problèmes, nous y apporterons les solutions

Berf, comme je l'ai dit, n'hésitez pas à formuler ne serait-ce que la question

Attention, le sens n'est pas du tout le même. Effectivement, le titre ne sera pas immédiatement compréhensible d'un débutant, mais il est bien plus précis.
A la limite, on peut remplacer "au départ de" par "sur un".

+1... je modifie le titre pour changer "au départ de" par "sur un"...

Par contre, une entrée supplémentaire pourrait aussi, effectivement, être "peut on appeler une fonction non constante dans une fonction membre constante?"

[nikko34]

peut être l'exemple de la variable globale/locale "const" peut être utilisé comme tout premier exemple

Code :

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

1
2
3
 
const std::string maString;
maString = "test"; // ça ne marche pas

et il faudrait peut être parler des const_iterator aussi, je pense que ça doit souvent revenir comme question