L'argument caché: this

Les membres de la classe sont dans la portée de la classe. Par définition une fonction membre pourra agir sur l'objet, pour cela, elle peut faire référence aux données membres de l'objet pour lequel elle a été invoquée. Comme on vient de le voir, ces données membres sont particulières pour chaque objet, alors que la fonction membre est partagée entre les membres de la classe; lors de l'appel d'une fonction membre il y a un ``argument caché'' qui permet l'accès aux données membres : l'adresse de l'objet (le this)

class A{
    int a;
public:
    void set(int i){a=i;};
    int get(){return a;}
}
//...
A x;
x.set(2);      // modifie la donnée membre a de x
cout<<x.get(); // retourne la valeur de a de x

On peut d'ailleurs explicitement faire référence à cet ``argument caché'' c'est le this.

class A {
  int x;
public:
  int valx() const {
    return x;   // equivalent a return this->x
  }
  int setx(int i){
    x=i;        // equivalent à this->x=i
  }
}a;

Un appel a.f(20), correspondra à un appel de A::f(20) avec `` this'' initialisé à l'adresse de a.

Pour une classe A, le type exact de this est A *const this. Dans certains cas, on peut être amené à utiliser ce this:

// chaines avec recopie
class chaine{
  char* buf;
  int lg;
public:
  chaine(const char *);
  chaine (const chaine &);          // recopie de chaine
  chaine operator=(const chaine &); // affectation avec recopie
  //...
};
chaine chaine::operator=(const chaine & ch1){
  if (this == &ch ) {
  // cas particulier de ch1 = ch1
    return *this
  }
  else{
    delete ch; //liberer l'espace
    ch=new char [taille=ch1.taille];
    strcpy(ch,ch1.ch);
    return *this;
  }
}

Le test (this == &ch ) est nécessaire, car on peut avoir une affectation ch = ch. De même, pour une liste:

class double_liste{
  double_liste *suivant;
  double_liste *precedent;
public:
  void ajouter(double_liste *);
  //...
};
void double_liste::ajouter(double_liste *p){
  p->suivant = suivant;
  p->precedent = this;
  suivant->precedent = p;
  suivant = p;
};

Par contre, même s'il peut être possible dans certaines anciennes implémentations d'affecter ce pointeur this, c'est tout à fait déconseillé (et contraire à la définition de this comme pointeur constant).