Какая сторона (левая или правая) из && (и) оператора, оценена в C++

Проблема в том, что оператор оценивает, как это:

, если (int alpha = (value1-value2 && alpha> 0,001))

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

Если ((int alpha = value1-value2) && (alpha> 0,001))

Вот статья листинг операторного приоритета и ассоциативности .

Из того, что я могу сказать, ваше намерение - это объявление временного, назначаемое ему значение Value1-Value2, затем проверьте результат и введите его, если он больше, чем некоторое значение. Альфа является объявлением как int, но вы, кажется, сравниваете его против двойного. Альфа должна быть двойной.

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

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

Linq to Сущностей на самом деле не выполняет ваш запрос, он интерпретирует ваш код, преобразует его в TSQL, а затем выполняет его на сервере.

Под обложками кодируется с учетом того, как работают операторы и общие функции и как они связаны с TSQL. Проблема в том, что разработчики L2E понятия не имеют, как именно вы внедряете IEqualityComparer. Поэтому они не могут понять, что, когда вы говорите класс A = = класс B вы имеете в виду (например) «Где Person.FirstName = = FirstName AND Person.LastName = = LastName».

Поэтому, когда интерпретатор L2E попадает в метод, который он не распознает, он выбрасывает это исключение.

Существует два способа обойти это. Во-первых, разработайте метод Where (), который удовлетворяет вашим требованиям равенства, но не опирается на какой-либо пользовательский метод. Другими словами, проверка равенства свойств экземпляра, а не метода Equals, определенного в классе.

Во-вторых, можно запустить выполнение запроса, а затем выполнить сравнение в памяти. Например:

var notThisItem = new Item{Id = "HurrDurr"};
var items = Db.Items.ToArray(); // Sql query executed here
var except = items.Except(notThisItem); // performed in memory

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

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

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

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

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

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

Попробуйте.

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

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

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

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

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

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

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

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

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, Alpha сначала оценивается. Поскольку оно не было назначено - и, возможно, не объявлено, правила не ясны в этом - она ​​производит ошибку.

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

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

GCC дает ошибка: ожидаемое выражение до «int» . Ну, может быть, это не ближе. С оригинальным утверждением GCC говорит о том же.

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

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

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

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

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

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

будет анализировать, то есть является декларацией int alpha инициализирована с значением1 - значением2 && alpha> 0,001 . Там нет оператора = в нем. И я надеюсь, что теперь вы можете понять, почему компилятор говорит, что вы читаете неинициализированную переменную в выражении инициализатора. Компилятор сделает то же самое жалобу на следующую декларацию

int alpha = alpha; // reading uninitialized variable

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

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

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

, либо разделить , если на два

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

Поскольку второе условие уже требуется Alpha , чтобы быть больше 0 , это не имеет большого смысла даже проверить первый, поэтому самая значимая вещь для того, чтобы Уменьшите все это до

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

, конечно, как уже отмечалось

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

, сравнение значения INT на 0,001 является действительным, но довольно странная вещь. Просто сделать

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

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

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

1. оценивает VALUE1 - значение2 и преобразует его на BOOL неявным сравнением против нуля - то есть , это эффективно (значение = - значение2)! = 0
2. Оценивается Alpha> 0,001 После усечения 0,001 - int (0) . На данный момент альфа не инициализируется.
3. рассчитывает логическое и и предыдущих двух оценок
4. преобразует логический результат логика и обратно в целое число

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

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

Согласно : 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)))

, отвечая на вопрос в заголовке, Это зависит от Типы операндов .

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

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

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

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

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

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

Первая часть вашего состояния является целым числом. Тогда вы делаете и с бул. Вы заставляете преобразование без необходимости вообще. Дайте, если и условные операторы именно то, что они просят: Bools.