Const antes ou depois da const?

Para começar, você provavelmente sabe que constpode ser usado para tornar os dados de um objeto ou um ponteiro não modificáveis ​​ou 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

No entanto, você também pode usar a sintaxe:

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

A única coisa que parece importar é de que lado do asterisco você colocou a constpalavra - chave. Pessoalmente, prefiro colocar constà esquerda do tipo para especificar que os dados não são modificáveis, pois acho que eles são melhores na minha mentalidade da esquerda para a direita, mas qual sintaxe veio primeiro?

Mais importante ainda, por que existem duas maneiras corretas de especificar constdados e em que situação você preferiria ou precisaria uma sobre a outra, se houver?

Editar:

Parece que essa foi uma decisão arbitrária quando o padrão de como os compiladores deveriam interpretar as coisas foi elaborado muito antes de eu nascer. Como consté aplicado ao que fica à esquerda da palavra-chave (por padrão?), Acho que eles descobriram que não havia mal em adicionar "atalhos" para aplicar palavras-chave e digitar qualificadores de outras maneiras pelo menos até que a declaração seja alterada por analisando um * ou & ...

Este foi o caso em C também, então eu estou assumindo?

por que existem duas maneiras corretas de especificar constdados e em que situação você preferiria ou precisaria uma sobre a outra, se houver?

Essencialmente, a razão pela qual a posição dos constespecificadores anteriores a um asterisco não importa é que a gramática C foi definida dessa maneira por Kernighan e Ritchie.

A razão pela qual eles definiram a gramática dessa maneira era provável que seu compilador C analisasse a entrada da esquerda para a direita e terminasse de processar cada token à medida que o consumia. Consumir o *token altera o estado da declaração atual para um tipo de ponteiro. Encontrar constdepois *significa que o constqualificador é aplicado a uma declaração de ponteiro; encontrá-lo antes dos *meios em que o qualificador é aplicado aos dados apontados.

Como o significado semântico não muda se o constqualificador aparecer antes ou depois dos especificadores de tipo, ele é aceito de qualquer maneira.

Um tipo semelhante de caso surge ao declarar ponteiros de função, em que:

• void * function1(void)declara uma função que retorna void *,
  

• void (* function2)(void)declara um ponteiro de função para uma função que retorna void.

Novamente, o que se deve notar é que a sintaxe do idioma suporta um analisador da esquerda para a direita.

A regra é:

const se aplica à coisa que resta dela. Se não houver nada à esquerda, isso se aplica à coisa certa.

Eu prefiro usar const à direita da coisa para ser const apenas porque é a maneira "original" de const ser definida.

Mas acho que esse é um ponto de vista muito subjetivo.

Eu prefiro a segunda sintaxe. Isso me ajuda a acompanhar o que é constante lendo a declaração de tipo da direita para a esquerda:

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

A ordem das palavras-chave em uma declaração não é tão fixa assim. Existem muitas alternativas para "a única ordem verdadeira". Como isso

int long const long unsigned volatile i = 0;

ou deveria ser

volatile unsigned long long int const i = 0;

??

A primeira regra é usar o formato que seus padrões de codificação local exigirem. Depois disso: colocar a constfrente não gera confusão quando os typedefs estão envolvidos, por exemplo:

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

Se o seu padrão de codificação permitir typedef de ponteiros, ele realmente deve insistir em colocar a const após o tipo. Em todos os casos, exceto quando aplicado ao tipo, const deve seguir o que se aplica; portanto, a coerência também argumenta a favor do const depois. Mas as diretrizes locais de codificação superam tudo isso; a diferença normalmente não é importante o suficiente para voltar e alterar todo o código existente.

Existem razões históricas para a esquerda ou direita serem aceitáveis. Stroustrup adicionou const ao C ++ em 1983 , mas não chegou ao C até C89 / C90.

Em C ++, há um bom motivo para sempre usar const à direita. Você será consistente em todos os lugares porque as funções de membro const devem ser declaradas desta maneira:

int getInt() const;