Pointeur this
Le this
pointeur est un pointeur accessible uniquement dans les fonctions membres non statiques d’un , struct
ou union
d’un class
type. 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 const
volatile
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
Commentaires
https://aka.ms/ContentUserFeedback.
Bientôt disponible : Tout au long de 2024, nous allons supprimer progressivement GitHub Issues comme mécanisme de commentaires pour le contenu et le remplacer par un nouveau système de commentaires. Pour plus d’informations, consultezEnvoyer et afficher des commentaires pour