Const prima o const dopo?

Per iniziare, probabilmente sai che constpuò essere utilizzato per rendere i dati di un oggetto o un puntatore non modificabili o entrambi.

const Object* obj; // can't change data
Object* const obj; // can't change pointer
const Object* const obj; // can't change data or pointer

Tuttavia puoi anche usare la sintassi:

Object const *obj; // same as const Object* obj;

L'unica cosa che sembra avere importanza è da che parte dell'asterisco inserisci la constparola chiave. Personalmente preferisco mettere consta sinistra del tipo per specificare che i suoi dati non sono modificabili in quanto trovo che leggano meglio nella mia mentalità da sinistra a destra ma quale sintassi è arrivata per prima?

Ancora più importante perché ci sono due modi corretti per specificare i constdati e in quale situazione preferiresti o avresti bisogno l'uno rispetto all'altro?

Modificare:

Quindi sembra che questa sia stata una decisione arbitraria quando lo standard su come i compilatori dovrebbero interpretare le cose è stato redatto molto prima che io nascessi. Poiché constviene applicato a ciò che si trova a sinistra della parola chiave (per impostazione predefinita?) Immagino che abbiano pensato che non ci fosse nulla di male nell'aggiungere "scorciatoie" per applicare parole chiave e digitare qualificatori in altri modi almeno fino a quando la dichiarazione cambia da analizzando un * o & ...

Questo è stato il caso anche in C, quindi presumo?

perché esistono due modi corretti per specificare i constdati e in quale situazione preferiresti o ne avresti bisogno?

In sostanza, il motivo per cui la posizione constall'interno degli specificatori prima di un asterisco non è importante è che la grammatica C è stata definita in questo modo da Kernighan e Ritchie.

Il motivo per cui hanno definito la grammatica in questo modo era probabile che il loro compilatore C analizzasse l'input da sinistra a destra e finisse di elaborare ciascun token man mano che lo consumava. Il consumo del *token modifica lo stato della dichiarazione corrente in un tipo di puntatore. L'incontro constdopo *significa che il constqualificatore viene applicato a una dichiarazione puntatore; incontrarlo prima del *modo in cui il qualificatore viene applicato ai dati indicati.

Poiché il significato semantico non cambia se il constqualificatore appare prima o dopo gli identificatori del tipo, viene accettato in entrambi i modi.

Un simile caso si presenta quando si dichiarano i puntatori a funzioni, dove:

• void * function1(void)dichiara una funzione che ritorna void *,
  

• void (* function2)(void)dichiara un puntatore a una funzione che ritorna void.

Ancora una volta la cosa da notare è che la sintassi del linguaggio supporta un parser da sinistra a destra.

La regola è:

const si applica alla cosa rimasta. Se non c'è nulla a sinistra, allora si applica alla cosa giusta.

Preferisco usare const a destra della cosa per essere const solo perché è il modo "originale" di definire const.

Ma penso che questo sia un punto di vista molto soggettivo.

Preferisco la seconda sintassi. Mi aiuta a tenere traccia di "cosa" è costante leggendo la dichiarazione del tipo da destra a sinistra:

Object * const obj;        // read right-to-left:  const pointer to Object
Object const * obj;        // read right-to-left:  pointer to const Object
Object const * const obj;  // read right-to-left:  const pointer to const Object

L'ordine delle parole chiave in una dichiarazione non è poi tutto risolto. Esistono molte alternative a "l'unico vero ordine". Come questo

int long const long unsigned volatile i = 0;

o dovrebbe essere

volatile unsigned long long int const i = 0;

??

La prima regola è quella di utilizzare qualsiasi formato richiesto dagli standard di codifica locali. Dopodiché: mettere constin primo piano non c'è fine alla confusione quando sono coinvolti i typedef, ad esempio:

typedef int* IntPtr;
const IntPtr p1;   // same as int* const p1;

Se il tuo standard di codifica consente a typedef di puntatori, allora dovrebbe davvero insistere nel mettere la const dopo il tipo. In ogni caso, ma quando applicato al tipo, const deve seguire ciò a cui si applica, quindi la coerenza sostiene anche a favore di const dopo. Ma le linee guida sulla codifica locale vincono tutte queste cose; la differenza non è normalmente abbastanza importante per tornare indietro e cambiare tutto il codice esistente.

Ci sono ragioni storiche che sono accettabili sia a destra che a sinistra. Stroustrup aveva aggiunto const a C ++ entro il 1983 , ma non arrivò a C fino a C89 / C90.

In C ++ c'è una buona ragione per usare sempre const sulla destra. Sarai coerente ovunque perché le funzioni membro const devono essere dichiarate in questo modo:

int getInt() const;