У меня есть быстрый вопрос о следующем выражении:Оператор коммутативности неравенства = в C++
int a_variable = 0;
if(0!=a_variable)
a_variable=1;
чем разница между «(0 != a_variable)» и «(a_variable != 0)»? У меня пока нет ошибок, но это неправильный способ использовать его?
Если вы забыли сообщение !, тогда первый даст ошибку (0 = a_variable), а второй приведет к havoc (a_variable = 0).
Кроме того, с помощью определяемых пользователем операторов вторая форма может быть реализована с помощью функции-члена, а первая может быть только функцией, не являющейся членом (возможно, другом). И это возможно, хотя ДЕЙСТВИТЕЛЬНО плохая идея, определить две формы по-разному. Конечно, поскольку a_variable - это int, тогда в этом примере не действуют определенные пользователем операторы.
+1 Ударь меня к нему. –
Нет никакой разницы между 0 != x и x != 0.
В langauges с перегрузкой оператора вы не знаете. Они действительно могут перегрузить оператор! = Для 'int & rhs', чтобы быть чем-то другим ... Конечно, в этом случае это int, но это определенно важно! – corsiKa
Любая разница, которую он может сделать, это порядок, в котором будут оцениваться аргументы. a != b обычно оценивает a, затем оценивает b и сравнивает их, в то время как b != a будет делать это наоборот. Однако я где-то слышал, что порядок оценки в некоторых случаях не определен.
Это не имеет большого значения с переменными или числами (если только переменная не является классом с перегруженным оператором !=), но это может иметь значение, когда вы сравниваете результаты некоторых вызовов функций.
Рассмотрим
int x = 1;
int f() {
x = -1;
return x;
}
int g() {
return x;
}
Предполагая, что операнды вычисляются слева направо, то вызов (f() != g()) даст false, потому что f() будет вычисляться в -1 и g() к -1 - в то время как (g() != f()) даст true, потому что g() оценит до 1 и f() - до -1.
Это просто пример - лучше избегать написания такого кода в реальной жизни!
Это недопустимое предположение, C++ не дает никаких обещаний о порядке оценки операндов для операторов сравнения. –
Да, и я указал на это. Я просто хотел указать, что это может быть разницей в таких функциях. Однако, насколько я знаю, когда оператор '! =' Перегружен в классе, тогда 'a! = B' расширяется до' a.operator! = (B) ', а затем левый операнд должен быть сначала оценивается. Или я ошибаюсь? – kFYatek
в 'a.operator! = (B)', как 'a', так и' b' оцениваются до вызова 'operator! =', И нет никакой гарантии, выполняется ли 'a' перед' b', ' b' перед 'a', или шаги каждого подвыражения смешаны. –
To nitpick, это коммутативность, а не ассоциативность. Ассоциативность будет заключаться в том, что '(a! = B)! = C' было таким же, как' a! = (B! = C) '(это вообще не так). –
На самом деле это симметрия. Операции являются коммутативными (иногда), отношения симметричны (иногда). – Beta
@Beta: Спасибо, это слово, о котором я не думал. Конечно, если бы я действительно хотел получить nitpicky, я бы спросил, была ли '! =' Операция или отношение, но давайте не будем туда сейчас. –