Является ли (4> y> 1) допустимым оператором в C ++? Как вы оцениваете это, если так?

Question

Это правильное выражение? Если да, можете ли вы переписать его так, чтобы он стал более понятным? Например, это так же, как (4 > y && y > 1)? Как вы оцениваете логические операторы в цепочке?

Answer 1

Оператор (4 > y > 1) анализируется следующим образом:

((4 > y) > 1)

Операторы сравнения < и > оценивают слева направо .

4 > y возвращает либо 0, либо 1 в зависимости от того, истинно оно или нет.

Тогда результат сравнивается с 1.

В этом случае, поскольку 0или 1 никогда не превышает 1, оператор целом всегда возвращает false .

---

Однако существует одно исключение:

Если y является классом и оператор > был перегружен для выполнения чего-то необычного.Тогда что-нибудь идет.

Например, это не удастся скомпилировать:

class mytype{
};

mytype operator>(int x,const mytype &y){
    return mytype();
}

int main(){

    mytype y;

    cout << (4 > y > 1) << endl;

    return 0;
}

Answer 2

Срок действия выражения

Да, это допустимое выражение, при условии, что y является или может быть неявно преобразовано в целое число.Если это не так и оператор > перегружен, это другая история, выходящая за рамки этого вопроса.

Он будет оцениваться слева направо как ((4 > y) > 1).

Предполагая y является целым числом, давайте рассмотрим две возможности.4 > y может вернуть true или false.Следующая часть фактически становится true > 1 или false > 1.

Учитывая неявное преобразование bool в int , существует две возможности: A) 4 > y возвращает true.true оценивается как 1.1 > 1 оценивается как ложное.Б) 4 > y возвращает false.false оценивается как 0.0 > 1 оценивается как ложное.

Независимо от того, что выражение будет оценивать как ложное.

Переписанная интерпретация

Я предполагаю, что вы намереваетесь((4 > y) && (y > 1)).

Пример

(4 > y > 1) - не то же самое, что (4 > y && y > 1).

Логические операторы

Логические операторы (!, &&, ||) используют логику короткого замыкания.

При заданном a && b, a будет оцениваться.Если a имеет значение true, тогда b будет оценено. Иначе, b не будет оцениваться .Что касается a || b, логика короткого замыкания работает в обратном порядке.a будет оцениваться.Поскольку выражение a вычисляется первым, если оно ложно, то вероятность того, что все выражение будет иметь значение true, отсутствует.

Учитывая a || b, a будет оцениваться.Если a оценивается как ложное, то b будет оцениваться. Иначе, b не будет оцениваться .Поскольку выражение a вычисляется первым, если оно истинно, то вероятность того, что все выражение будет иметь значение false, отсутствует.

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

Answer 3

Я думаю, что это правильное выражение (не утверждение), но, вероятно, не делает то, что вы хотите.Оценивается слева направо как (4 > y) > 1.Тест 4 > y будет иметь значение 0 (false) или 1 (true), а все выражение всегда будет равно 0 (false).

Answer 4

4> y будет принимать логическое значение true или false. Тогда остаток выражения по существу равен [true | false]> 1, что не имеет смысла.

Answer 5

4> y> 1 -> МОЖЕТ БЫТЬ ВСЕГДА, если у - класс !!

 #include <iostream>
 #include <string>

 struct num{ int n; };

 struct op{ bool v; struct num n; };

 struct op  operator > (int x, num n){
  struct op o = { x > n.n, n };
  return o;
 }
 bool operator > (struct op o, int x)
{
    return o.v && o.n.n > x;
}

int main()
{


    struct num y = { 2 } ;
    if (  4 > y > 1 ) {  std::cout << "4 > y > 1 TRUE" << std::endl; }
    else { std::cout << "4 > y > 1  ALWAYS FALSE" << std::endl; }
}