Const antes o const después?

Para empezar, probablemente sepa que constpuede usarse para hacer que los datos de un objeto o un puntero no sean modificables o ambos.

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

Sin embargo, también puede usar la sintaxis:

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

Lo único que parece importar es qué lado del asterisco coloca la constpalabra clave. Personalmente, prefiero poner consta la izquierda del tipo para especificar que sus datos no se pueden modificar, ya que creo que se lee mejor en mi mentalidad de izquierda a derecha, pero ¿qué sintaxis vino primero?

Más importante aún, ¿por qué hay dos formas correctas de especificar constdatos y en qué situación preferiría o necesitaría una sobre la otra si la hubiera?

Editar:

Parece que esta fue una decisión arbitraria cuando el estándar de cómo los compiladores deberían interpretar las cosas fue redactado mucho antes de que yo naciera. Dado que constse aplica a lo que está a la izquierda de la palabra clave (¿de manera predeterminada?) Supongo que pensaron que no era perjudicial agregar "accesos directos" para aplicar palabras clave y calificadores de tipo de otras maneras, al menos hasta el momento en que la declaración cambie analizando un * o & ...

Este fue el caso también en C, entonces supongo.

¿Por qué hay dos formas correctas de especificar constdatos y en qué situación preferiría o necesitaría una sobre la otra si la hubiera?

Esencialmente, la razón por la cual la posición de los constespecificadores antes de un asterisco no importa es que Kernighan y Ritchie definieron la gramática C de esa manera.

La razón por la que definieron la gramática de esta manera era probable que su compilador de C analizara la entrada de izquierda a derecha y terminara de procesar cada token a medida que lo consumía. El consumo del *token cambia el estado de la declaración actual a un tipo de puntero. Encuentro constdespués *significa que el constcalificador se aplica a una declaración de puntero; encontrarlo antes de que el *calificador se aplique a los datos apuntados.

Debido a que el significado semántico no cambia si el constcalificador aparece antes o después de los especificadores de tipo, se acepta de cualquier manera.

Un tipo similar de caso surge al declarar punteros de función, donde:

• void * function1(void)declara una función que devuelve void *,
  

• void (* function2)(void)declara un puntero de función a una función que devuelve void.

Nuevamente, lo que hay que notar es que la sintaxis del lenguaje admite un analizador de izquierda a derecha.

La regla es:

const se aplica a lo que queda de él. Si no hay nada a la izquierda, entonces se aplica a la cosa derecha.

Prefiero usar const a la derecha de la cosa para ser const solo porque es la forma "original" en que se define const.

Pero creo que este es un punto de vista muy subjetivo.

Prefiero la segunda sintaxis. Me ayuda a hacer un seguimiento de 'qué' es constante leyendo la declaración de tipo de derecha a izquierda:

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

El orden de las palabras clave en una declaración no es tan fijo. Hay muchas alternativas para "el único orden verdadero". Me gusta esto

int long const long unsigned volatile i = 0;

o debería ser

volatile unsigned long long int const i = 0;

??

La primera regla es usar el formato que requieran sus estándares de codificación locales. Después de eso: poner el constfrente lleva a un sinfín de confusión cuando están involucrados typedefs, por ejemplo:

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

Si su estándar de codificación permite typedef's de punteros, entonces realmente debería insistir en poner la constante después del tipo. En todos los casos, pero cuando se aplica al tipo, const debe seguir a lo que se aplica, por lo que la coherencia también argumenta a favor del const posterior. Pero las pautas de codificación locales prevalecen sobre todas estas; La diferencia no suele ser lo suficientemente importante como para volver atrás y cambiar todo el código existente.

Hay razones históricas por las que se acepta izquierda o derecha. Stroustrup había agregado constante a C ++ en 1983 , pero no llegó a C hasta C89 / C90.

En C ++ hay una buena razón para usar siempre const a la derecha. Serás coherente en todas partes porque las funciones miembro const deben declararse de esta manera:

int getInt() const;