Какая сторона (левая или правая) оператора && (и) вычисляется в C ++

Это разбирается как:

if (int alpha = (value1-value2 && (alpha > 0.001)))

... потому что && имеет более высокий "приоритет синтаксического анализа", чем = - что, вероятно, не то, что вам нужно. Пытаться:

int alpha = value1-value2; 
if (alpha && (alpha > 0.001))

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

В других ответах вам уже объяснялось, что ваше условие не анализируется так, как вы думаете, что оно анализируется, хотя во многих ответах есть очевидная ошибка ссылки на приоритет оператора = в условии, хотя на самом деле там вообще нет оператора =. Правильное объяснение состоит в том, что когда вы объявляете переменную в условии if, синтаксис аналогичен объявлению с инициализатором, поэтому все это анализируется так же, как

int alpha = value1 - value2 && alpha > 0.001;

будет проанализирован, т.е. это объявление int alpha, инициализированное с помощью value1 - value2 && alpha > 0.001. В нем нет оператора =. И я надеюсь, что теперь вы понимаете, почему компилятор говорит, что вы читаете неинициализированную переменную в выражении инициализатора. Компилятор подал бы такую ​​же жалобу на следующее объявление

int alpha = alpha; // reading uninitialized variable

по той же причине.

Чтобы достичь того, что вы буквально пытаетесь выразить, вы должны либо заранее объявить alpha

int alpha;
if ((alpha = value1 - value2) && alpha > 0.001) {
  // whatever 
}

или разделите свой if на два

if (int alpha = value1 - value2) 
  if (alpha > 0.001) {
    // whatever 
  }

Однако, поскольку второе условие уже требует, чтобы alpha было больше, чем 0, нет особого смысла даже проверять первое, поэтому наиболее значимым вариантом было бы просто свести все это к

int alpha = value1 - value2;
if (alpha > 0.001) {
  // whatever 
}

Конечно, как уже отмечали другие, сравнение значения int со значением 0.001 является допустимым, но довольно странным делом. Просто сделать

int alpha = value1 - value2;
if (alpha > 0) {
  // whatever 
}

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

if ((int alpha = value1-value2) && (alpha > 0.001))

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

Лучше, если каждый оператор будет либо «командой», либо «запросом».

И будет намного, намного лучше, если условие внутри «if» будет очень четко читаемым и однозначно логическим. Не целое число, ничего, просто булево.

Первая часть вашего условия - целое число. Затем вы выполняете и с помощью bool. Вы вызываете конверсию без необходимости. Дайте if и условные операторы именно то, что они просят: bools.

Отвечая на вопрос в заголовке, это зависит от типов операндов.

Для встроенных типов && закорачивает, что означает, что LHS оценивается, а если оно ложно, то RHS вообще не оценивается.

Для определяемых пользователем типов, которые имеют перегрузку operator&&, короткое замыкание не выполняется. Обе стороны оцениваются в неопределенном порядке, а затем вызывается функция.

Я думаю, что другие ответили на ваш вопрос.

Если не ошибаюсь, эта операция не определена. Присвоение переменной и последующее обращение к той же переменной в одном операторе не определено.

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

Он оценивается слева направо.

Однако в вашем случае назначение - это последнее, что должно произойти, и все они будут вести себя так (где альфа используется как часть расчета для получения результата для его инициализации):

if (int alpha = (value1-value2 && alpha > 0.001))

Вы не можете смешивать объявления переменных в сложных выражениях, поэтому следующее не будет компилироваться:

if ((int alpha = value1-value2) && (alpha > 0.001))

Поэтому вам нужно разделить его на две строки:

int alpha = value1 - value2;
if (alpha > 0.001)

if (int alpha = value1-value2 && alpha > 0.001)

Согласно правила будут оцениваться в следующем порядке:

1.  (value1-value2)   [evaluate subtraction]
2.  && (left side)    [test left side]
3.  (alpha > 0.001)   [evaluated only if value-value2 != 0]
4.  && (right side)   [test right side]
4.  alpha =           [assignment]

На шаге 3 сначала оценивается альфа. Поскольку он не был назначен - и, возможно, не объявлен, правила на этот счет не ясны - это вызывает ошибку.

Недостаток в том, что присваивание имеет более низкий приоритет, чем &&. Что еще не работает, но уже ближе:

if (int alpha = value1-value2, alpha > 0.001)

Gcc дает error: expected expression before ‘int’. Ну может не ближе. В исходном заявлении gcc говорит то же самое.

Я предполагаю, что это потому, что вы объявляете хранилище внутри оператора if. Я даже не думал, что это будет компилироваться.

Попробуй это.

int alpha;
if ((alpha=value1-value2) && alpha>0.001)

Но я не думаю, что это делает то, что вам нужно. У вас есть alpha как int, и вы затем сравниваете его со значением с плавающей запятой. Первая часть оператора && будет возвращать истину, пока альфа не равна нулю, а вторая часть вернет истину, если альфа больше 0. Так что вам, вероятно, следует сделать это.

int alpha;
if ((alpha=value1-value2)>0)

или для гораздо более читаемого кода

int alpha=value1-value2
if (alpha>0)

Но чтобы ответить на ваш исходный вопрос: && выполняется слева направо и замыкается, когда ответ очевиден. То есть, если первая часть && ложна, вторая даже не оценивается!

Вот статья, список приоритетов и ассоциативности операторов.

Насколько я могу судить, ваше намерение состоит в том, чтобы объявить временное значение, присвоить ему значение value1-value2, затем проверить результат и ввести блок if, если он больше некоторого значения. alpha объявляется как int, но вы, похоже, сравниваете его с двойным. альфа должна быть двойной.

Вы творчески используете временные конструкции. Ясный часто лучше, чем милый. Вместо этого сделайте это:

double alpha = value1-value2;
if (alpha > 0.001)

Согласно: http://en.wikipedia.org/wiki/Operators_in_C_and_C%2B%2B

- LtR
> LtR
&& LtR
= RtL

учитывая ваш пример

(int alpha = value1-value2 && alpha > 0.001)
(int alpha = (value1-value2) && alpha > 0.001)
(int alpha = (value1-value2) && (alpha > 0.001))
(int alpha = (value1-value2) && (alpha > 0.001))
(int alpha = ((value1-value2) && (alpha > 0.001)))

Как написано, это выражение делает следующее:

1. Вычисляет value1 - value2 и преобразует его в bool путем неявного сравнения с нулем, т. Е. Фактически (value1 - value2) != 0
2. Оценивает alpha > 0.001 после усечения 0.001 до int(0). На этом этапе alpha не инициализирован.
3. Вычисляет логическое И двух предыдущих оценок.
4. Преобразует логический результат логического И обратно в целое число.

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

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

Проблема в том, что выражение оценивается так:

if (int alpha = (value1-value2 && alpha > 0.001))

Используйте круглые скобки, чтобы исправить левую и правую части оператора &&:

if ((int alpha = value1-value2) && (alpha > 0.001))