Pointeur this

Le pointeur this est accessible uniquement dans les fonctions membres non statiques de type class, struct ou union. Il pointe vers l'objet pour lequel la fonction membre est appelée. Les fonctions membres statiques n’ont pas de pointeur this.

Syntaxe

this
this->member-identifier

Notes

Le pointeur this d’un objet ne fait pas partie de l’objet lui-même. Il ne fait pas partie du résultat d’une instruction sizeof sur l’objet. Lorsqu’une fonction membre non statique est appelée pour un objet, le compilateur passe l’adresse de l’objet à la fonction comme argument masqué. Par exemple, l'appel de fonction suivant :

myDate.setMonth( 3 );

peut être interprété comme suit :

setMonth( &myDate, 3 );

L’adresse de l’objet est disponible à partir de la fonction membre en tant que pointeur this. La plupart des utilisations du pointeur this sont implicites. Il est permis, bien qu’inutile, d’utiliser un pointeur this explicite lorsqu’il est fait référence aux membres de la class. Par exemple :

void Date::setMonth( int mn )
{
   month = mn;            // These three statements
   this->month = mn;      // are equivalent
   (*this).month = mn;
}

L'expression *this est utilisée couramment pour retourner l'objet actuel d'une fonction membre :

return *this;

Le pointeur this est également utilisé pour la protection contre les autoréférences :

if (&Object != this) {
// do not execute in cases of self-reference

Remarque

Le pointeur this étant non modifiable, les assignations au pointeur this ne sont pas autorisées. Les implémentations précédentes de C++ autorisaient les assignations à this.

Parfois, le pointeur this est utilisé directement, par exemple pour manipuler les structures de données auto-référentielles, où l’adresse de l’objet actuel est requise.

Exemple

// this_pointer.cpp
// compile with: /EHsc

#include <iostream>
#include <string.h>

using namespace std;

class Buf
{
public:
    Buf( char* szBuffer, size_t sizeOfBuffer );
    Buf& operator=( const Buf & );
    void Display() { cout << buffer << endl; }

private:
    char*   buffer;
    size_t  sizeOfBuffer;
};

Buf::Buf( char* szBuffer, size_t sizeOfBuffer )
{
    sizeOfBuffer++; // account for a NULL terminator

    buffer = new char[ sizeOfBuffer ];
    if (buffer)
    {
        strcpy_s( buffer, sizeOfBuffer, szBuffer );
        sizeOfBuffer = sizeOfBuffer;
    }
}

Buf& Buf::operator=( const Buf &otherbuf )
{
    if( &otherbuf != this )
    {
        if (buffer)
            delete [] buffer;

        sizeOfBuffer =  strlen( otherbuf.buffer ) + 1;
        buffer = new char[sizeOfBuffer];
        strcpy_s( buffer, sizeOfBuffer, otherbuf.buffer );
    }
    return *this;
}

int main()
{
    Buf myBuf( "my buffer", 10 );
    Buf yourBuf( "your buffer", 12 );

    // Display 'my buffer'
    myBuf.Display();

    // assignment operator
    myBuf = yourBuf;

    // Display 'your buffer'
    myBuf.Display();
}

my buffer
your buffer

Type du pointeur this

Le type du pointeur this change selon que la déclaration de fonction inclut les mots clés const et/ou volatile. La syntaxe suivante décrit le type de this dans une fonction membre :

[cv-qualifier-list] class-type * const this

Le déclarateur de la fonction membre détermine cv-qualifier-list. Il peut être const ou volatile (ou les deux). class-type est le nom de la class.

Le pointeur this ne peut pas être réassigné. Les qualificateurs const ou volatile utilisés dans la déclaration de fonction membre s’appliquent à l’instance class vers laquelle pointe le pointeur this dans l’étendue de cette fonction, comme indiqué dans le tableau suivant :

Déclaration de fonction membre	type de pointeur this pour une class nommée myClass
void Func()	myClass *
void Func() const	const myClass *
void Func() volatile	volatile myClass *
void Func() const volatile	const volatile myClass *

Le tableau suivant explique plus en détail const et volatile.

Sémantique des modificateurs this

Modificateur	Signification
const	Impossible de changer les données membres ; impossible d'appeler les fonctions membres qui ne sont pas const.
volatile	Les données membres sont chargées à partir de la mémoire chaque fois que vous y accédez ; certaines optimisations sont désactivées.

Il est incorrect de passer un objet const à une fonction membre qui n’est pas const.

De même, il est aussi incorrect de passer un objet volatile à une fonction membre qui n’est pas volatile.

Les fonctions membres déclarées en tant que const ne peuvent pas changer les données membres. Dans les fonctions const, le pointeur this est un pointeur vers un objet const.

Remarque

Les constructeurs et les destructeurs ne peuvent pas être déclarés en tant que const ou volatile. Ils peuvent, toutefois, être appelés sur des objets const ou volatile.

Voir aussi

Mots clés