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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Здравствуйте, 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 );

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

V>Угадай.

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

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

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

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

x != FALSE

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

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

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

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

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

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

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

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

Здравствуйте, 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))

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

Здравствуйте, 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, вообще она не реализована). Т.е. не ошибешься