Questo è [0] sicuro in C++?

Question

This earlier question chiede cosa significa this[0] in C#. In C++, this[0] significa "l'elemento zeroth dell'array puntato da this".

È garantito che non causa un comportamento indefinito in C++ per fare riferimento all'oggetto destinatario in questo modo? Non sto sostenendo l'utilizzo di questa sintassi, e sono per lo più curioso di sapere se la specifica garantisce che funzionerà sempre.

Grazie!

Answer 1

Per qualsiasi puntatore di oggetto valido p, p[0] equivale a *p. Quindi this[0] equivale a *this. Non c'è nient'altro. Proprio come è possibile annullare il riferimento a qualsiasi puntatore valido utilizzando [0], è possibile annullare il riferimento a this.

In altre parole, è solo un modo "difficile" per scrivere *this. Può essere usato per offuscare il codice. Può essere probabilmente usato in alcune circostanze specifiche anche per scopi utili, dal momento che qualsiasi oggetto autonomo può essere pensato come una matrice di dimensione 1. (Da C++ 03, Operatori additivi: "Ai fini di questi operatori, un puntatore a un oggetto nonarray si comporta come un puntatore al primo elemento di una matrice di lunghezza uno con il tipo dell'oggetto come tipo di elemento. ")

PS Come ha osservato Johannes nei commenti, utilizzando le funzionalità di C++ 11 è possibile creare un contesto in cui this è un puntatore a un tipo incompleto. In tal caso, l'espressione this[0] non è più valida, mentre l'espressione *this rimane valida.

Answer 2

this[0] è lo stesso di *(this + 0), quindi effettivamente questo va bene (anche se un po 'strano).

Answer 3

È equivalente (per definizione) a *(this + 0), che è lo stesso di *this. È sicuro e ben definito, ma strano.

Answer 4

Sì, è la stessa cosa di *this

Answer 5

per quanto ne so praticamente this[0] è esattamente la stessa di *this, come this è solo un normale puntatore. Quindi sì, è sicuro da usare.

array[1] sarebbe lo stesso di *(array + 1) (quando array è valido) fyi ...

Answer 6

this[0] è uguale a *(this + sizeof(this)*0) quindi è abbastanza sicuro

Aggiunto piccolo test in risposta al commento

struct A 
{ 
    void * _a; 
    int _b; 

    A * getThis(int index) 
    { 
     return &(this[index]); 
    } 
}; 

int main(int argc, char * argv[]) 
{ 
    A mas[100]; 

    std::cout << ((long long) mas[0].getThis(50) == (long long) &(mas[50])) << std::endl; 
    return 0; 
}