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

Оператор (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;
}

Действительность выражения

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

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

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

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

В любом случае выражение будет оцениваться как ложное.

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

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

Пример

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

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

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

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

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

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

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

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

4 > y > 1 --> МОЖЕТ БЫТЬ В ЛЮБОМ СЛУЧАЕ, если y - класс!!.

 #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; }
}