Константа до или константа после?

Для начала вы, вероятно, знаете, что с constего помощью можно сделать либо данные объекта, либо указатель неизменяемыми, либо и то, и другое.

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

Однако вы также можете использовать синтаксис:

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

Единственное, что кажется важным, - это то, с какой стороны звездочки вы помещаете constключевое слово. Лично я предпочитаю ставить constслева от типа, чтобы указать, что данные не подлежат изменению, поскольку я считаю, что он лучше читается в моем мышлении слева направо, но какой синтаксис появился первым?

Что еще более важно, почему существует два правильных способа указания constданных и в какой ситуации вы бы предпочли или понадобились бы один другому, если таковой имеется?

Редактировать:

Похоже, это было произвольное решение, когда стандарт того, как компиляторы должны интерпретировать вещи, был разработан задолго до моего рождения. Поскольку constприменяется к тому, что находится слева от ключевого слова (по умолчанию?) Я думаю, они решили, что добавление «ярлыков» для применения ключевых слов и квалификаторов типов другими способами не повредит, по крайней мере, до тех пор, пока объявление не изменится на разбор * или & ...

Полагаю, так было и в C?

почему существует два правильных способа указания constданных и в какой ситуации вы бы предпочли или понадобились бы один другому, если таковой имеется?

По сути, причина того, что положение constспецификаторов внутри перед звездочкой не имеет значения, заключается в том, что грамматика C была определена таким образом Керниганом и Ричи.

Причина, по которой они определили грамматику таким образом, заключалась в том, что их компилятор C анализировал ввод слева направо и завершал обработку каждого токена по мере его использования. Использование *токена изменяет состояние текущего объявления на тип указателя. Встреча constпосле *означает, что constквалификатор применяется к объявлению указателя; обнаружение его до того, *как квалификатор применяется к указанным данным.

Поскольку семантическое значение не изменяется, если constквалификатор появляется до или после спецификаторов типа, он принимается в любом случае.

Аналогичный случай возникает при объявлении указателей на функции, где:

• void * function1(void)объявляет функцию, которая возвращает void *,
  

• void (* function2)(void)объявляет указатель функции на возвращаемую функцию void.

Снова следует отметить, что синтаксис языка поддерживает синтаксический анализатор слева направо.

Правило такое:

const применяется к тому, что осталось от него. Если слева ничего нет, то это относится к тому, что находится справа от него.

Я предпочитаю использовать const справа от объекта, чтобы быть const только потому, что это «оригинальный» способ определения const.

Но я считаю, что это очень субъективная точка зрения.

Я предпочитаю второй синтаксис. Это помогает мне отслеживать "что" постоянно, читая объявление типа справа налево:

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

Порядок ключевых слов в объявлении не так уж и фиксирован. Есть много альтернатив «единому истинному порядку». Как это

int long const long unsigned volatile i = 0;

или должно быть

volatile unsigned long long int const i = 0;

??

Первое правило - использовать тот формат, который требуется в соответствии с вашими местными стандартами кодирования. После этого: constвставка вперед приводит к бесконечной путанице, когда задействованы определения типов, например:

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

Если ваш стандарт кодирования допускает typedef указателей, то он действительно должен настаивать на том, чтобы после типа помещалась константа. В любом случае, кроме применения к типу, константа должна следовать за тем, к чему она применяется, поэтому согласованность также свидетельствует в пользу константы после. Но местные правила кодирования важнее всего этого; разница обычно не настолько важна, чтобы вернуться и изменить весь существующий код.

Есть исторические причины, по которым приемлемо либо левое, либо правое. Страуструп добавил const в C ++ к 1983 году , но до C89 / C90 он не попал в C.

В C ++ есть веская причина всегда использовать const справа. Вы будете последовательны везде, потому что функции-члены const должны быть объявлены следующим образом:

int getInt() const;

C использует синтаксис с написанием справа налево. Просто прочтите объявления справа налево:

int var = 0;

// one is a pointer to a const int
int const * one = &var; 
// two is a pointer to an int const (same as "const int")
const int * two = &var; 

// three is a constant pointer to an int
int * const three = &var;

Это влияет на первое, что осталось от "const".

Чтобы получить больше удовольствия, прочтите это руководство: http://cseweb.ucsd.edu/~ricko/rt_lt.rule.html