Ваше мнение об объявлении констант в методах …? [закрытый]

В целом я думаю, что это всегда - хорошая идея заставить Ваши намерения очистить этот путь по ряду причин:

• Легче понять то, что Вы имели в виду, когда Вы записали это.
• Для других легче рассуждать о Вашем коде, когда они читают его.
• Для компилятора легче сделать выводы о том, что Вы хотите сделать.
• Для компилятора легче предотвратить логические ошибки.

Создание постоянных переменных является совершенно законным способом выполнить все вышеупомянутое в конкретном случае предположения, "Я не хочу, чтобы эта переменная изменила свое значение".

Если идентификатор используется только в функции, объявляется, почему загрязняют более широкий объем им. Если значение, присвоенное идентификатору, не должно изменять затем маркировку, это как таковой полезно для ошибок определения, а также компилятора.

От эффективного C++ Scott Meyers (глава 3):

Использовать const когда это возможно.

Замечательная вещь о const это, это позволяет Вам указывать семантическое ограничение - конкретный объект не должен быть изменен - и компиляторы осуществят то ограничение. Это позволяет Вам связываться с обоими компиляторами и другими программистами, что значение должно остаться инвариантным. Каждый раз, когда это верно, несомненно, необходимо будет сказать так, потому что тот способ, которым Вы включаете в список помощь своих компиляторов в проверку ограничения, не нарушен.

Идея состоит в том, что Вы только оставляете материал изменяемым, если существует определенная причина его — он помогает обосновать о Вашем коде тот путь.

Конечно, значение, которому нужно дать имя, но это не должно изменяться, нужно назвать константой, начиная с того, именно это это.

Несомненно, иногда константа может быть частью интерфейса и/или должна использоваться в более широком объеме, и затем это должно быть объявлено в подходящем месте. Но если это действительно локально, затем я ничто не нахожу странным о создании его так.

Если Вы собираетесь использовать статически типизированный язык, то, почему не только идут целые девять ярдов? Использовать const указать, что Вы не хотите, чтобы значение когда-либо изменилось после первого присвоения. Позвольте компилятору прослушивать Вас, если Вы попадаете впросак.

Мне вполне понравилось const ключевое слово в параметрах метода C++ по точно этой причине...

Если значение ограничено по объему к методу (т.е. не используется внешне, но используется несколько раз внутри), то это проявляет здравый смысл. В частности, при работе с xml у Вас могло бы быть что-то как xml пространство имен, которое используется (только в одном методе) несколько раз, но она, конечно, не что-то, что Вы хотите поддержать несколько раз - константа, идеально.

С точки зрения C# это также оказывает влияние для закрытий:

const int i = 27;
Func<Foo,bool> predicate = foo => foo.Bar == i;

отличается от:

int i = 27;
Func<Foo,bool> predicate = foo => foo.Bar == i;

Второе должно генерировать класс получения, и т.д. - первым является просто статический метод (без состояния), и более эффективный (никакой объект "кучи" на использование, нет разыменуйте, и т.д.).

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

Спорный недостаток - то, что Вы не можете (легко) передать его в код, который берет ссылку неконстанты, которую это на самом деле не изменяет. Если Вы действительно верите в C++, это - на самом деле скрытое преимущество, потому что он поощряет Вас делать остальную часть Вашего кода корректной константой. Но если необходимо внести быстрые изменения (например, при отладке), или если Вы уже опубликовали API и не можете изменить его, затем он смотрит на Вас как проклятая хорошая маскировка.

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

Я склонен использовать его, когда я помню, и не пот это, если я забываю. Я вытаскиваю большую часть использования из него, когда я должен удалить константу из переменной. Это говорит мне, что моя исходная концепция той переменной была неправильной, и я должен тщательно проверить, что никакое выражение с помощью нее на самом деле не полагается на нее не изменение. Учитывая, что C++ имеет ключевое слово константы, если Вы собираетесь написать код, который полагается на переменную не изменение, можно также получить компилятор на стороне.

Это обычно не стоит взволновать об оптимизациях компилятора. Хороший компилятор (gcc) может сказать, что, если Вы не изменяете переменную, и не берут ссылок на него, затем это может применить соответствующие оптимизации, отмечаете ли Вы его константа или нет.

Много закаленных разработчиков C++ на самом деле полагает, что "константа" должна быть значением по умолчанию, и необходимо было бы явно объявить, что что-то было неконстантой. Конечно, используйте константу каждый раз, когда имеет смысл делать так. Если что-то не должно изменяться в функции, сделайте ее константой. Это ничего не стоит, и это помогает объявить намерение.

Я склонен объявлять любое значение, которое не изменяет константу/финал и поощряет других в командах, с которыми я работаю сделать то же. Обычно в Java, где финал означает 'присвоенный однажды и однажды только', а не константа C, 'инициализировал и не изменился', можно создать методы, где единственными не постоянные величины являются итераторы цикла.

Объявление переменной константы предотвратит Вас от случайного изменения ее значения. Это может также привести к оптимизации компилятора.

Сделайте это везде, где это возможно:

• это делает код легким для чтения;

• это просит, чтобы компилятор проверил Ваши ошибки случая:

  void some_class1::doSomething(const some_class2& cs2)
  {
     // code
     cs2 = cs2; // !!! misspelling cs2 instead cs2_
     //
  }
  

• это помогает Вам с совместимостью с const- правильный код;

• это помогает с инкапсуляцией.

Я никогда не видел это прежде, но это действительно имеет смысл. Я позволил бы программисту продолжать идти путем, которым он уже разрабатывал.

Для тестов это является очевидно большим. Что касается 'обычного' кода, Вы могли посмотреть на него от обоих путей. На одном конце объем чего-либо в коде должен быть как можно меньше. На другом конце Вы могли сказать, что константа, более вероятно, будет использоваться troughout класс и, как должны для этого объявлять, на уровне класса в любом случае, предотвращает двойные константы.

Я сказал бы, объявил бы константы уровня класса только и константы метода использования только, когда существует серьезное основание для него. Одна причина могла состоять в том, что цель методов состоит в том, чтобы обеспечить абстракцию на некотором вызове API, и Вы требуете некоторых постоянных величин для этого. В этом случае Вы не хотите, чтобы константы уровня класса создали помехи остальной части класса.