Qual è la differenza tra l’operatore punto (.) E -> in C ++?

Qual è la differenza tra l’operatore punto (.) E -> in C ++?

foo->bar() è uguale a (*foo).bar() .

Le parentesi qui sopra sono necessarie a causa della forza di legame del * e . operatori.

*foo.bar() non funziona perché l’operatore Dot ( . ) viene valutato per primo (vedere la precedenza degli operatori )

L’operatore Dot ( . ) Non può essere sovraccaricato, l’operatore della freccia ( -> ) può essere sovraccaricato.

L’operatore Punto ( . ) Non può essere applicato ai puntatori.

Vedi anche: Qual è l’operatore della freccia (->) sinonimo di in C ++?

Per un puntatore, potremmo semplicemente usarlo

 *pointervariable.foo 

Ma il . l’operatore ha una precedenza maggiore rispetto all’operatore * , quindi . viene valutato per primo. Quindi dobbiamo forzare questo con parentesi:

 (*pointervariable).foo 

Ma scrivere il () è sempre difficile, così hanno sviluppato -> come una scorciatoia per dire la stessa cosa. Se si accede a una proprietà di un object o riferimento a un object, utilizzare . Se si accede a una proprietà di un object tramite un puntatore, utilizzare ->

L’operatore punto non può essere sovraccaricato, l’operatore freccia può essere sovraccaricato. L’operatore di frecce è generalmente pensato per essere applicato a puntatori (o oggetti che si comportano come puntatori, come puntatori intelligenti). L’operatore punto non può essere applicato ai puntatori.

MODIFICA Quando applicato all’operatore di freccia del puntatore equivale a applicare l’operatore punto a punta (il campo ptr-> è equivalente a (* ptr) .field)

L’operatore della freccia è come un punto, ad eccezione del fatto che dereferisce prima un puntatore. foo.bar() chiama il metodo bar() sull’object foo , foo->bar chiama la bar metodi sull’object puntato dal puntatore foo .

 pSomething->someMember 

è equivalente a

 (*pSomething).someMember 

Il . l’operatore è per l’accesso diretto ai membri.

 object.Field 

La freccia dereferisce un puntatore in modo da poter accedere all’object / memoria a cui punta

 pClass->Field 

Il bersaglio. il punto funziona sugli oggetti; la freccia funziona sui puntatori agli oggetti.

 std::string str("foo"); std::string * pstr = new std::string("foo"); str.size (); pstr->size (); 

Si noti che l’operatore -> non può essere utilizzato per determinate cose, ad esempio l’accesso all’operatore [].

 #include  int main() { std::vector iVec; iVec.push_back(42); std::vector* iVecPtr = &iVec; //int i = iVecPtr->[0]; // Does not compile int i = (*iVecPtr)[0]; // Compiles. } 

È semplice, ogni volta che vedi

  x->y 

sapere che è lo stesso di

  (*x).y 

Usa -> quando hai un puntatore. Usa quando hai una struttura (class).

Quando si desidera utilizzare l’attributo punto appartenente alla struttura . :

 structure.attribute 

Quando vuoi puntare a un attributo che abbia un riferimento alla memoria per puntatore usa -> :

 pointer->method; 

o come:

 (*pointer).method 

Il . L’operatore (punto) viene in genere utilizzato per ottenere un campo / chiamare un metodo da un’istanza di class (o un campo / metodo statico di una class).

p.myField, p.myMethod () – istanza p di una class

L’operatore -> (freccia) è usato per ottenere un campo / chiamare un metodo dal contenuto indicato dalla class.

p-> myField, p-> myMethod () – p indica una class

Il -> è semplicemente zucchero sintattico per un dereferenziamento puntatore,

Come altri hanno detto:

pointer-> metodo ();

è un metodo semplice per dire:

(* Puntatore) .method ();

Per divertirti di più, dai un’occhiata a Binky e alla sua bacchetta magica di dereferenziazione:

http://www.youtube.com/watch?v=UvoHwFvAvQE

La differenza più semplice tra i due è che “->” dereferenzia un puntatore prima di andare a vedere i campi degli oggetti, la funzione ecc. Mentre “.” non prima di tutto. Usa “->” quando hai un puntatore a un object e usa “.” quando lavori con l’istanza reale di un object.

Un altro modo equivalente per risolvere il problema potrebbe essere quello di utilizzare prima il dereferenziazione “*” sul puntatore e quindi utilizzare semplicemente “.”. Saltiamo middleman usando “->”.

Ci sono altre differenze, ma le altre risposte lo hanno ampiamente trattato.

Se hai uno sfondo in Java questo potrebbe confonderti, dato che, in Java, tutto è puntatore. Ciò significa che non c’è motivo di avere un simbolo che non derifera prima il puntatore. In c ++ però devi essere un po ‘più attento a ricordare cosa è e cosa non è un puntatore, e potrebbe essere una buona idea etichettarlo con il prefisso “p_” o semplicemente “p”.

L’operatore -> viene usato quando stiamo lavorando con un puntatore e il punto è usato diversamente. Quindi se abbiamo una class struct come:

 struct class{ int num_students; int yr_grad; }; 

e abbiamo un’istanza di una class * curr_class (puntatore di class), quindi per ottenere l’accesso al numero di studenti che faremmo

 cout << curr_class->num_students << endl; 

Nel caso avessimo un semplice object di class, ad esempio class_2016, lo faremmo

 cout << class_2016.num_students << endl; 

Per il puntatore alla class l'operatore -> è equivalente a

 (*obj).mem_var 

Nota: per una class, anche il modo di accedere alle funzioni membro della class sarà lo stesso