Pointeur this

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

Syntaxe

this
this->member-identifier

Notes

Le pointeur d’un this objet ne fait pas partie de l’objet lui-même. Il ne fait pas partie du résultat d’une sizeof instruction sur l’objet. Lorsqu’une fonction membre non statique est appelée pour un objet, le compilateur transmet l’adresse de l’objet à la fonction en tant qu’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 this pointeur. La plupart des this utilisations de pointeur sont implicites. Il est légal, bien qu’inutile, d’utiliser un explicite this lorsque vous faites référence à des membres du 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 this pointeur est également utilisé pour se protéger contre l’auto-référence :

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

Remarque

Étant donné que le this pointeur n’est pas modifiable, les affectations au this pointeur ne sont pas autorisées. Implémentations antérieures de l’affectation autorisée C++ à this.

Parfois, le this pointeur est utilisé directement, par exemple pour manipuler des données structautoré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 this pointeur

Le this type du pointeur change selon que la déclaration de fonction inclut ou constvolatile mot clé s. La syntaxe suivante décrit le type d’une this 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 du class.

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

Déclaration de fonction membre	type de this pointeur pour un class nom 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 et const «volatile ».

Sémantique des this modificateurs

Modificateur	Signification
const	Impossible de modifier les données de membre ; ne peut pas appeler des fonctions membres qui ne sont pas const.
volatile	Les données membres sont chargées à partir de la mémoire chaque fois qu’elles sont sollicitées ; désactive certaines optimisations.

Il s’agit d’une erreur pour passer un const objet à une fonction membre qui n’est pas const.

De même, il s’agit également d’une erreur pour passer un volatile objet à une fonction membre qui n’est pas volatile.

Les fonctions membres déclarées comme const ne peuvent pas modifier les données de membre. Dans const les fonctions, le this pointeur est un pointeur vers un const objet.

Remarque

Constructors et destructors ne peuvent pas être déclarés en tant que const ou volatile. Toutefois, elles peuvent être appelées sur ou volatile sur const des objets.

Voir aussi

Mots clés