Puntatore this

Il this puntatore è un puntatore accessibile solo all'interno delle funzioni membro non statiche di un classtipo , structo union . Viene puntato l'oggetto per il quale è chiamata la funzione membro. Le funzioni membro statiche non hanno un this puntatore.

Sintassi

this
this->member-identifier

Osservazioni:

Il puntatore di this un oggetto non fa parte dell'oggetto stesso. Non fa parte del risultato di un'istruzione sizeof sull'oggetto . Quando viene chiamata una funzione membro non statica per un oggetto, il compilatore passa l'indirizzo dell'oggetto alla funzione come argomento nascosto. Ad esempio, la seguente chiamata di funzione:

myDate.setMonth( 3 );

può essere interpretato come:

setMonth( &myDate, 3 );

L'indirizzo dell'oggetto è disponibile all'interno della funzione membro come this puntatore. La maggior parte degli this usi del puntatore è implicita. È legale, anche se non necessario, usare un oggetto esplicito this quando si fa riferimento ai membri di class. Ad esempio:

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

L'espressione *this viene in genere utilizzata per restituire l'oggetto corrente da una funzione membro:

return *this;

Il this puntatore viene usato anche per proteggersi dal self-reference:

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

Nota

Poiché il this puntatore non è modificabile, le assegnazioni al this puntatore non sono consentite. Implementazioni precedenti di C++ consentite l'assegnazione a this.

In alcuni casi, il this puntatore viene usato direttamente, ad esempio per modificare strutture di dati auto-referenziale, in cui è necessario l'indirizzo dell'oggetto corrente.

Esempio

// 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

Tipo del puntatore this

Il this tipo del puntatore cambia a seconda che la dichiarazione di funzione includa le const parole chiave e/o volatile . La sintassi seguente descrive il tipo di this in una funzione membro:

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

Il dichiaratore della funzione membro determina cv-qualifier-list. Può essere const o volatile (o entrambi). class-type è il nome dell'oggetto class.

Il this puntatore non può essere riassegnato. I const qualificatori o volatile usati nella dichiarazione di funzione membro si applicano all'istanza class a cui punta il this puntatore, nell'ambito di tale funzione, come illustrato nella tabella seguente:

Dichiarazione di funzione membro	tipo di this puntatore per un class oggetto denominato myClass
void Func()	myClass *
void Func() const	const myClass *
void Func() volatile	volatile myClass *
void Func() const volatile	const volatile myClass *

Nella tabella seguente vengono illustrate altre informazioni su const e volatile.

Semantica dei this modificatori

Modificatore	significato
const	Non è possibile modificare i dati dei membri; non può richiamare funzioni membro che non constsono .
volatile	I dati dei membri vengono caricati dalla memoria ogni volta che si accede; disabilita alcune ottimizzazioni.

Si tratta di un errore per passare un const oggetto a una funzione membro che non constè .

Analogamente, è anche un errore passare un volatile oggetto a una funzione membro che non volatileè .

Le funzioni membro dichiarate come const non possono modificare i dati dei membri. Nelle const funzioni il this puntatore è un puntatore a un const oggetto .

Nota

I costruttori e i distruttori non possono essere dichiarati come const o volatile. Tuttavia, possono essere richiamati su const oggetti o volatile .

Vedi anche

Parole chiave