Discussion :

[lachose]

bonjour;
bon voila je n'arrive a faire la différence entre ces deux déclaration :

Code :

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

1
2
reference front ();
const_reference front () const;

je sais que const veut dire constante mais je vois pas son utilité ici

[alskaar]

tu peux trouver 3 const sur la definition d'une methode

Code :

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

1
2
 
const int  methode1( const int argument ) const

le premier c'est la valeur de retour qui est const
le second c'est largument qui est const
le troisieme const indique que la methode ne modifie pas l'objet (objet const)

enfin la faq doit etre mieu que mon expliquation

dans ton cas le premier front permet de recup une reference qui te permetra d'utiliser des methodes de sets alors que le second non

[G-OnZa]

Particularité des fonctions membres 'const' :
elles ne doivent pas modifier les données membres
et ne doivent pas appeler de fonctions membres qui ne sont pas const (erreur à la compilation, pas facile à déceler)

[nicroman]

C'est simple... prenons un exemple:

Code :

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

1
2
3
4
5
6
 
class MaClasse
{
     // (3)                    (1)                      (2)
     const UnObjet&   GetObjet(const param& unParametre) const;
};

Le modificateur 'const' en (1) indique au code appelant la fonction que même si on passe une référence (la même chose s'applique aux pointeurs, vu que reference ~ pointeur non null), l'objet passé en paramètre ne sera pas modifié. C'est non seulement utile au programmeur, mais aussi à l'optimiseur.
Attention "const toto&" n'est pas une référence constante sur toto, mais bien une reference sur un toto constant (c'est l'ordre anglais: constant toto reference).

Le 'const' en (2) est le corrolaire du premier. Il indique au code appelant la fonction, que l'objet sur lequel on appelle la fonction ne sera pas modifié.
Attention... ca ne veut par dire quie dans les fait la mémoire représentant l'objet n'est pas modifiée, juste que vis à vis de l'exterieur, des ses propriétés, de la manière dont l'objet se comporte, etc..., il SEMBLE ne pas avoir changé. Tu peux très bien incrémenter un compteur d'appels dans l'objet, voir même faire du 'cache' (très pratique en particulier sur les chaines de caractères).
Par exemple, un arbre binaire, et une fonction retournant le chemin complet depuis la racine est typiquement 'const' (les noeuds ne sont pas modifiés), mais peut très bien stocker ce chemin dans chaque noeud, et ainsi être bien plus efficace lors des appels suivants.
Le mot clef à connaitre dans ce cas est "volatile".

Le 'const' en (3), pour finir, indique comment la valeur de retour peut être utilisée... Encore une fois il sagit d'une référence sur un objet constant.

(1) et (3) ne sont absoluement pas liés.... Par exemple:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
class Exemple
{
     static Logger    mLogger;
 
     int    mValue;
 
     // permet de 'lire' mValue d'un objet Exemple constant
     inline const int&  value() const
     { return mValue; }
 
     // permet de 'modifier' mValue d'un objet Example (non constant forcément):
     // Exemple a;
     // a.value() = 48;
     inline int&           value()
     { return mValue; }
 
     // permet d'accéder au logger de Exemple (il reste constant)
     inline Logger&      logger() const
     { return mLogger; }
};