Что означает двойной отрицательный знак в исходном коде:

static inline void input_report_key(struct input_dev *dev, unsigned int code, int value)
{
input_event(dev, EV_KEY, code, !!value);
}

Здравствуйте, ChistovSE, Вы писали:

CSE>Что означает двойной отрицательный знак в исходном коде:

CSE>  static inline void input_report_key(struct input_dev *dev, unsigned int code, int value)
CSE>{
CSE>    input_event(dev, EV_KEY, code, !!value);  /* *** */
CSE>}

Он обозначает сравнение с нулём /* *** */ эквивалентно этому:

    input_event(dev, EV_KEY, code, value != 0 );

Здравствуйте, Erop, Вы писали:

E>Он обозначает сравнение с нулём /* *** */ эквивалентно этому:

    input_event(dev, EV_KEY, code, value != 0 );

Спасибо за помощь, а то гуглить замучался .

CSE>Что означает двойной отрицательный знак в исходном коде:
Это такой трюк для превращение value в логическую единицу. Полученное значение можно сравнивать с другой логической единицей оператором =.

Здравствуйте, ChistovSE, Вы писали:

CSE> Спасибо за помощь, а то гуглить замучался .
Всегда пожалуйста.
Для "спасибо" тут есть кнопки

Здравствуйте, Vamp, Вы писали:

V>Это такой трюк для превращение value в логическую единицу. Полученное значение можно сравнивать с другой логической единицей оператором =.

1) Лучше, всё-таки сравнивать оператором ==
2) Никогда не понимал, зачем так страдать. Нет бы написать понятно ххх != 0

E>1) Лучше, всё-таки сравнивать оператором ==
Ну, это понятно. Опчтк.
E>2) Никогда не понимал, зачем так страдать. Нет бы написать понятно ххх != 0
Запись короче.

Здравствуйте, Vamp, Вы писали:

V>Запись короче.
Типа на символ? прикольный подход к кодированию...

E>Типа на символ? прикольный подход к кодированию...
Гораздо больше, чем на один символ.
x != 0 — 6 символов.
!!х — 3 символа. В 2 раза быстрее!

Здравствуйте, Erop, Вы писали:

E>2) Никогда не понимал, зачем так страдать. Нет бы написать понятно ххх != 0

Как я понимаю, это пошло-поехало от умных указателей. Там оператор "!" переопределяется с целью изучить внутреннее содержимое, а не обертку.

p = NULL;
if (p)
{
  // do something
}
if (!!p)
{
  // do something
}

Если p — обычный указатель, то оба if пролетят мимо, а если p — "умный", то в первый if мы таки заскочим. Получается, что написание !! превращает код в легко мигрирующий (или безопасную заготовку для шаблона).

Здравствуйте, Vamp, Вы писали:

V>Гораздо больше, чем на один символ.
V>x != 0 — 6 символов.
V>!!х — 3 символа. В 2 раза быстрее!

Ну пробелы-то можно и не писать. Кроме того надо ещё учитывать, что не x, а value

Так что получаем !!value (7символов) против value!=0 (8символов)... Не такая уж и экономия-экономия.


Но подход всё равно прикольный Наверное тогда ещё все переменные надо называть одной буквой, а функции двумя, а в больших прогах тремя

Здравствуйте, Mr.Delphist, Вы писали:

MD>Если p — обычный указатель, то оба if пролетят мимо, а если p — "умный", то в первый if мы таки заскочим. Получается, что написание !! превращает код в легко мигрирующий (или безопасную заготовку для шаблона).

Не понятно, чем же != 0 плох в этом контексте.

Здравствуйте, Mr.Delphist, Вы писали:

MD>Как я понимаю, это пошло-поехало от умных указателей. Там оператор "!" переопределяется с целью изучить внутреннее содержимое, а не обертку.

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

Здравствуйте, Vamp, Вы писали:

E>>1) Лучше, всё-таки сравнивать оператором ==
V>Ну, это понятно. Опчтк.

Интересно, какая именно. Так как сравнивать можно и оператором ^ и оператором -, ну и != и == тоже, кстати, но *крутые С-кодеры*, я так понимаю, таких лёгких путей не юзают?

E>Интересно, какая именно.
Угадай.

Здравствуйте, Vamp, Вы писали:

V>Угадай.

Неужели крышка?

E>2) Никогда не понимал, зачем так страдать. Нет бы написать понятно ххх != 0

это видимо зависит от людей и их бэкграунда.

Для меня более понятно !!x
Почему. Взгляд сразу видит двойное отрицание, сразу очевидно что двойное отрицание не меняет логического значения x. С другой стороны известно, что результат любого логического выражения это либо 1 либо 0.
Поэтому сразу видно, что логическое значение не меняется, и оно только нормализуется к 1/0

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

E>Неужели крышка?
А вот и не угадал. Ты проиграл, с тебя миллион юаней.

Здравствуйте, dilmah, Вы писали:

D>Когда я смотрю на x != 0 мне уже нужно думать, а что же тут происходит, мозг не находит такой очевидной подпорки как двойное отрицание, тут нет автоматизма, мне нужно на пару секунд задуматься, чтобы понять что логическое значение не меняется.

Прикольно. А если

x != FALSE

Как бы пишут: "икс не ноль/ложь". Неужели нечитабельно?

Кроме того, в приведённом контексте название переменной наводит на мысли, что это таки число. Что такое "двойное отрицание пяти", например?

Здравствуйте, Vamp, Вы писали:

V>А вот и не угадал. Ты проиграл, с тебя миллион юаней.

А зачем тебе юани, кстати? США скоро планирует сдаваться КНР?

E>А зачем тебе юани, кстати? США скоро планирует сдаваться КНР?
Ответа нет. Оффтопик и флейм прекращен в зародыше.

Здравствуйте, Vamp, Вы писали:

E>>Типа на символ? прикольный подход к кодированию...
V>Гораздо больше, чем на один символ.
V>x != 0 — 6 символов.
V>!!х — 3 символа. В 2 раза быстрее!

А что если "x" в коде выглядит как a — b? Тогда еще пару скобочек посчитать придется

E>Кроме того, в приведённом контексте название переменной наводит на мысли, что это таки число. Что такое "двойное отрицание пяти", например?

ну а в чем проблема. В Си исходно булевого типа не было, их роль играли целые.
Двойное отрицание не меняет логического значения и только нормализует в 1/0.
Пятерка нормализуется в единицу.

Здравствуйте, Erop, Вы писали:

E>Здравствуйте, Mr.Delphist, Вы писали:

MD>>Если p — обычный указатель, то оба if пролетят мимо, а если p — "умный", то в первый if мы таки заскочим. Получается, что написание !! превращает код в легко мигрирующий (или безопасную заготовку для шаблона).

E>Не понятно, чем же != 0 плох в этом контексте.
Ничем не плох. Имею такую версию (например). '!!' располагается целиком слева и оттого (дичайше) напоминает операторную запись — в математическом смысле (Fx или F(x)). То есть это (вощемто) оператор "естественного вложения" какого-то объемлющего множества — "кольца" — в {0, 1}.

Здравствуйте, dilmah, Вы писали:


E>>Кроме того, в приведённом контексте название переменной наводит на мысли, что это таки число. Что такое "двойное отрицание пяти", например?

D>ну а в чем проблема. В Си исходно булевого типа не было, их роль играли целые.
Проблема в том, что нечитабельно. Если у тебя value -- это число, а не логический тип, то не понятно как-то, что такое его отрицание
Кроме того, приличные люди в С писали что-то типа

typedef int BOOL;

D>Двойное отрицание не меняет логического значения и только нормализует в 1/0.
D>Пятерка нормализуется в единицу.
Спасибо, С я знаю. Но я не понимаю, зачем писать Сщные ребусы вместо понятного кода

Здравствуйте, Warturtle, Вы писали:

W>Имею такую версию (например). '!!' располагается целиком слева и оттого (дичайше) напоминает операторную запись — в математическом смысле (Fx или F(x)). То есть это (вощемто) оператор "естественного вложения" какого-то объемлющего множества — "кольца" — в {0, 1}.

Что-то мне так кажется, что таким соображением никто ни разу не пользовался, при написании !!

>2) Никогда не понимал, зачем так страдать. Нет бы написать понятно ххх != 0
почему страдать? если есть BOOL a, b; // где BOOL — какой-нть очередной typedef int
то в написании if (!!a == !!b) меньше страданий, чем в if ((a && b) || (!a && !b))

Здравствуйте, Вумудщзук, Вы писали:

>>2) Никогда не понимал, зачем так страдать. Нет бы написать понятно ххх != 0
В>почему страдать? если есть BOOL a, b; // где BOOL — какой-нть очередной typedef int
В>то в написании if (!!a == !!b) меньше страданий, чем в if ((a && b) || (!a && !b))

Боже ж мой! Ты контекст исходного сообщения видел?

Здравствуйте, Erop, Вы писали:

E>2) Никогда не понимал, зачем так страдать. Нет бы написать понятно ххх != 0

С int действительно разницы никакой. Код смахивает на С-шный, но если бы там был шаблонный аргумент:

static inline void input_report_key(struct input_dev *dev, unsigned int code, T value)

то есть мнение, что !! наиболее безопасный способ конвертации в bool:
http://www.artima.com/cppsource/safebool.html
Лучше, конечно, такого избегать.

>Боже ж мой! Ты контекст исходного сообщения видел?
а что с ним не так ?

Здравствуйте, Erop, Вы писали:

E>2) Никогда не понимал, зачем так страдать. Нет бы написать понятно ххх != 0
Для ненулевых значение удобно писать проверки

if ( i )
{
}

минус данной конструкции — warning(losing data бла-бла int to bool)

E>2) Никогда не понимал, зачем так страдать. Нет бы написать понятно ххх != 0

Это невсегда возможно. Одно время был подход определять оператор! для преобразования в bool (т.к. сам operator bool имеет некоторые недостатки). Поэтому и писали так:

class A
{
public:
    bool operator!() const
    {
        return !good_;
    }
private:
    bool good_;  
};

Поэтому не сравнишь объект класса с нулем.

MD>Как я понимаю, это пошло-поехало от умных указателей. Там оператор "!" переопределяется с целью изучить внутреннее содержимое, а не обертку.

MD>

MD>p = NULL;
MD>if (p)
MD>{
MD>  // do something
MD>}
MD>if (!!p)
MD>{
MD>  // do something
MD>}
MD>

MD>Если p — обычный указатель, то оба if пролетят мимо, а если p — "умный", то в первый if мы таки заскочим. Получается, что написание !! превращает код в легко мигрирующий (или безопасную заготовку для шаблона).

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

On 05/08/10 21:50, Erop wrote:

> 1) Лучше, всё-таки сравнивать оператором ==
> 2) Никогда не понимал, зачем так страдать. Нет бы написать понятно ххх != 0
А ещё есть javascript, и, наверняка ещё какие-нибудь подобные языки, где тип может быть не только число, а много чего — (строка, пустой массив и т.п.), которые тоже имеют логическое значение false, и привести к логическому типу проще всего именно с помощью !!.

Здравствуйте, Erop, Вы писали:

E>2) Никогда не понимал, зачем так страдать. Нет бы написать понятно ххх != 0

Это разделяет читателей программы на 2 лагеря: равных автору в мудрости своей, и тех, кто ничего не понял

Здравствуйте, Pzz, Вы писали:

E>>2) Никогда не понимал, зачем так страдать. Нет бы написать понятно ххх != 0
Pzz>Это разделяет читателей программы на 2 лагеря: равных автору в мудрости своей, и тех, кто ничего не понял

Есть ещё и третий лагерь -- те, кто понял всё, кроме того, зачем так извращаться