Autour de Linux

On déclare une fonction membre constante en faisant suivre sa déclaration du mot-clé const.

struct S
{
  void f(){}
  void f()const{}
}

La différence entre les deux fonctions f() est que la version non-constante ne peut être appelée pour des objets constants de type S.
La version constante de f() garantit aussi qu’aucune donnée membre de S ne sera modifiée. Autrement dit vous ne pouvez modifier l’objet de type S à l’intérieur de la fonction.

struct S
{
  S(){}
  void f(){}
  void f()const{}
  void g(){}
  void h()const{}
};

int main()
{
  S s;          // objet non-constant
  s.f();        // appelle la fonction non-constante
  s.g();
  s.h();
  
  const S cs;   // objet constant
  cs.f();       // appelle la fonction constante
  // cs.g();    // erreur! 
  cs.h();

  return 0;
}

Ceci montre bien que la fonction f() non-constante est appelée pour un objet non-constant et qu’à l’inverse, si l’objet est constant, c’est la fonction f() constante qui sera appelée. cs.g() donne une erreur parce que cs étant un objet constant, on ne peut appeler une fonction non constante pour un objet constant. Ce qui est logique puisque cs est de type S constant. On ne peut donc pas appeler une fonction de S qui modifierait l’objet. Et justement, les fonctions membres constantes garantissent que l’objet ne sera pas modifié. Conséquence, on ne peut appeler que des fonctions membres constantes pour des objets constants.
Remarquons aussi que s.h() est valide. Une fonction membre constante peut être appelée pour des objets constants aussi bien que non-constants.