puntatore ed e commerciale posizione con const in C ++

Possibile duplicato:
Dichiarando i puntatori; asterisco a sinistra oa destra dello spazio tra il tipo e il nome?

Mi sono sempre chiesto quale sia la posizione esatta esatta per mettere * e & . sembra che C ++ sia piuttosto tollerante su dove mettere questi marchi. Ad esempio, mi sembra che puntatore ed e commerciale siano stati messi sia a destra sia a sinistra di una parola chiave o nel mezzo di due parole chiave, ma a volte confusamente sembrano voler dire la stessa cosa, specialmente se usati insieme a const

 void f1(structure_type const& parameter) void f2(structure_type const &parameter) void f2(structure_type const *sptr); void f2(structure_type const* sptr); void f2(structure_type const * sptr); 

Gli esempi non sono esaustivi. Li vedo ovunque mentre vengono dichiarati o passati a una funzione. Intendono anche la stessa cosa? Ma vedo anche casi mentre inserisco * influenza quale object viene indicato come puntatore (probabilmente nel caso in cui * trova tra due parole chiave).

MODIFICATO:

 int const *Constant int const * Constant // this above two seem the same to me, both as pointer to a constant value int const* Constant // EDIT: this one seems the same as above. instead of a constant pointer const int * Constant // this is also a pointer to a constant value, but the word order changed while the pointer position stays the same, rather confusing. int* const Constant int * const Constant // instead, these two are constant pointers 

Quindi ho concluso questo:

 T const* p; // pointer to const T const T* p // seems same from above T* const p; // const pointer to T 

Eppure, questo mi ha confuso. Il compilatore non si preoccupa della posizione e della spaziatura richiesta per loro?

Modifica: voglio sapere in generale della posizione è importante. Se sì, in quali casi.

Lo spazio bianco conta solo nella misura in cui mantiene i token dal correre insieme e (ad esempio) creando un singolo token, quindi (per esempio) int x è ovviamente diverso da intx .

Quando hai a che fare con qualcosa come: int const*x; , lo spazio bianco su entrambe le dimensioni del * fa assolutamente alcuna differenza per il compilatore.

La differenza tra un pointer to const int e il const pointer to int dipende da quale lato del * const è attivo.

 int const *x; // pointer to const int int *const x; // const pointer to int 

La differenza principale è la leggibilità quando / se si definiscono / dichiarano più oggetti nella stessa dichiarazione.

 int* x, y; int *x, y; 

Nella prima, qualcuno potrebbe pensare che x e y siano puntatori a int – ma in realtà, x è un puntatore a un int, e y è un int. Agli occhi di alcune persone, il secondo riflette questo fatto in modo più accurato.

Un modo per prevenire qualsiasi interpretazione errata è definire sempre e solo un object alla volta:

 int *x; int y; 

Per ognuno di questi, l’interpretazione corretta è abbastanza facile se si ignorano completamente gli spazi (tranne per dirti dove finisce un toke e ne inizia un altro, quindi sai “const int” è due token) e leggi da destra a sinistra, leggendo * as ” puntatore a “. Ad esempio: int volatile * const x; viene letto come “x è un puntatore const a un int volatile”.

 int const *Constant int const * Constant int const* Constant 

Tutto quanto sopra intende dichiarare un puntatore non costante a un numero intero costante.

Regola semplice:

Se const segue dopo * si applica al puntatore se non si applica all’object puntato. La spaziatura non ha importanza.

Entrambi i posizionamenti & e * nella dichiarazione delle variabili sono accettabili e dipendono solo dal proprio gusto. Significano strettamente la stessa cosa, creando rispettivamente un puntatore e un riferimento.

Tuttavia, il posizionamento della parola chiave const è primordiale, in quanto una int const* variable const int* variable indica un puntatore costante a una costante non costante e la const int* variable è un puntatore non costante a una costante int.