Следует ли тщательно знать приоритет операторов?

StackOverflow https://stackoverflow.com/questions/465706

Вопрос

Должен ли программист тщательно следить за приоритетом операторов?Использование фигурных скобок для группировки выражений должно быть нормальным, не так ли?Я всегда использую брекеты, чтобы быть в безопасности.И когда мне задают вопрос о приоритете, я не могу сразу ответить.

Это было полезно?

Решение

Для очень распространённых операторов - да, это стоит знать.Если поставить скобки вокруг все в противном случае ваш код будет нечитаемым (или его легко спутать с Lisp).

Для более непонятных операторов - я явно избегал изучая их.Если я начну принимать как должное слишком много вещей, о которых я не могу разумно ожидать, что другие разработчики узнают, я начну писать код, который я смогу легко прочитать, но никто другой не сможет.Лучший пример — операторы смены.Я даже не знаю (точно - подозреваю), какой из них без скобок будет рассматриваться одинаково, но я абсолютно уверен, что понятнее:

int x = (y << shift) + offset;

или

int x = y << (shift + offset);

Другие советы

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

Несколько лет назад я видел эту таблицу приоритетов для C:

  • Умножение и деление происходят раньше сложения и вычитания.
  • Используйте круглые скобки.

Это немного упрощенно, но идея правильная.

Я использую шпаргалку для всех, кроме самых распространенных арифметических операторов. Если что-то немного сложнее, я использую явные скобки, чтобы прояснить свои намерения.

Причина, по которой мне нравится использовать письменное руководство, а не запоминание приоритетов, заключается в том, что я часто работаю на нескольких языках с немного разными правилами. Запоминание чего-либо, кроме самых распространенных операторов, может привести к ошибкам, когда я начну слишком полагаться на свою память.

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

Я знаю основы (например, деление и умножение выше, чем сложение и вычитание), но мне нужно поискать что-то более эзотерическое.

Я обычно использую скобки, чтобы прояснить свое намерение. Я думаю, что он читается лучше и избегает ошибок из-за неправильных предположений.

Это, безусловно, не повредит, и может помочь вам прочитать код с тонкостями превосходства, написанными другими.

Однако на практике, вероятно, лучше не предполагать, что те, кто поддерживает ваш код, будут обладать одинаковыми навыками, поэтому, хотя вы и сможете читать этот код, вы можете не захотеть писать код, который использует слишком много преимуществ взаимодействий. Лучше использовать конструкции, которые безошибочны, даже если здесь и там есть несколько лишних скобок.

Я с тобой в этом; использование скобок для явного определения приоритета - это всегда хорошая идея. Это делает ваш код легче для чтения, и ваши намерения являются явными.

С учетом вышесказанного вы должны знать, где искать информацию о приоритетах операторов, если вы поддерживаете чужой код.

Практически: не совсем. Если это так сложно, что вам нужно знать приоритет оператора, вам все равно следует разбить выражение на куски. Кроме того, скобки спасут вас!

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

Вы должны понимать это, чтобы иметь возможность читать код, написанный кем-то, кто не использовал парены везде.

Я не думаю, что " всегда в скобках " хорошее эмпирическое правило. Код, имеющий слишком много паренов, становится труднее читать, чем необходимо. Как: 

(a * b) + c

просто глупо. Где-то есть баланс, и задача состоит в том, чтобы его найти. Как и во многих других вещах, речь идет о применении здравого смысла.

Quick, который имеет более высокий приоритет в T-SQL:И против ИЛИ.

SELECT c.Name
FROM [Customer] c LEFT JOIN [Order] o
  ON c.CustomerKey = o.CustomerId
WHERE c.Name like 'B%'
  OR c.Name like 'Z%'
  AND o.CustomerId is NULL

Как только вы изучите приоритет этих операторов до такой степени, что вы полагаться на этот приоритет, вы обречены либо на:

  • Используйте их неправильно.
  • Страдайте на ошибках других, которые не выучат эти операторы и не смогут прочитать ваш код.

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

Когда-то в колледже я знал наизусть все правила прецедента. Оказавшись в реальном мире, я обнаружил, что большинство людей не знают их наизусть. Если я проверял какой-то действительный код, который зависел от некоторых правил предшествования, я последовательно получал ту же самую обратную связь &, Добавлял паренсы, чтобы сделать это очевидным & Quot ;.

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

Если ваше выражение настолько длинное, что неясно, что произойдет первым, разбейте его на несколько строк, используя временные переменные для промежуточных результатов. Затем вы вводите ясность без суматохи круглых скобок и можете использовать описательные имена для временных переменных, чтобы сделать вещи еще более ясными.

Нет!

Если вы не уверены в приоритете, вполне вероятно, что кто-то еще, читающий код, может интерпретировать его неправильно.

Если вы не уверены, просто 

 ( .. )
соответствующие фрагменты кода, тогда не будет никакой двусмысленности ни для вас, ни для кого-либо еще.

У меня никогда не было 100% контроля над правилами предшествования, потому что я работаю на нескольких языках (C, C ++, perl, bash и иногда из TCL / TK.). В разные годы на протяжении многих лет я работал с несколькими разными языками ассемблера и одним или двумя несоответствующими компиляторами.

Я не могу держать в голове полностью подробные правила приоритетов - мне приходится слишком часто переключаться между наборами правил.

Да Для:

  • * / + -
  • && || И или

Нет/Может быть:

  • << >> & | ^

При написании a == a & some_flag очень легко обмануть себя.

Даже если бы я предложил не изучать правила приоритета, используя для ясности круглые скобки и временные символы (помните: код предназначен для чтения людьми ), иногда оператором таблица приоритетов пригодится.

Предполагая, что вы знаете о концепции приоритета операторов (что, как я полагаю, каждый знает, по классам математики), я бы предпочел не предполагать никаких знаний со стороны читателя ...

... за исключением здравого смысла: как уже указывалось, выражения типа a * b + c можно понять, используя знания математических классов. Логические выражения типа a < 4 && a > 0 могут быть поняты, потому что логичнее сравнивать сравнения, чем &&.

С другой стороны, не существует здравого смысла смешивать побитовые операторы с нормальной арифметикой, поэтому лучше использовать круглые скобки там. Также нет здравого смысла для приоритета || над <=> (или наоборот?), Так что используйте там круглые скобки.

Лицензировано под: CC-BY-SA с атрибуция
Не связан с StackOverflow
scroll top