S>Но скорее всего оно не находило поддержки по простой причине: люди (т.е. программисты) не склоны производить ВЫЧИСЛЕНИЯ с булевскими типами (ну какой прок скажем от операции bool + bool или bool — bool, что будет в результате?).

ВЫЧИСЛЕНИЯ над булевскими типами производятся постоянно, только операции для этого используются не + и -, а && || ! (а также "исключающее или" которого в С нет, но оно с успехом заменяется на сравнение булевских типов). Если же программист не склонен производить такие вычисления, то это свидетельствует о его недостаточной квалификации, значит ему следует выполнить 2...3 десятка упражнений на эту тему чтобы вычисления над булевскими типами стали для него столь же привычными как и над обычными числами.

SS>Логический xor — это оператор !=
SS>Xor = x1!=x2

При условии что x1 и x2 — это bool, а не BOOL

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

S>>Но скорее всего оно не находило поддержки по простой причине: люди (т.е. программисты) не склоны производить ВЫЧИСЛЕНИЯ с булевскими типами (ну какой прок скажем от операции bool + bool или bool — bool, что будет в результате?).

SWW>ВЫЧИСЛЕНИЯ над булевскими типами производятся постоянно, только операции для этого используются не + и -, а && || ! (а также "исключающее или" которого в С нет, но оно с успехом заменяется на сравнение булевских типов). Если же программист не склонен производить такие вычисления, то это свидетельствует о его недостаточной квалификации, значит ему следует выполнить 2...3 десятка упражнений на эту тему чтобы вычисления над булевскими типами стали для него столь же привычными как и над обычными числами.

Интересный вывод. Я польщен.

Здравствуйте, Евгений Коробко, Вы писали:

ЕК>Здравствуйте, Lorenzo_LAMAS, Вы писали:

S>>>Вы, батенька, логические операторы с побитовыми не путайте, для разных целей всё-таки.

L_L>>Так он не путает. Ему хочется &&= для переменных типа bool.

ЕК>Совершенно верно. И совершенно непонятно, почему для логических операторов нет сдвоенных с присваиванием.
ЕК>Я жуе не говорю про логический xor.
ЕК>Конечно, можно сделать
ЕК>inline bool Xor(bool x1,bool x2)
ЕК>{
ЕК> return (x1&&(!x2))||(x2&&(!x1))
ЕК>}
ЕК>Но, согласитель, некрасиво. И вряд ли эффективно.

Могу предложить такой вариант...

inline bool xor(bool a, bool b)
{
  return a != b;
}

или

inline bool xor(int a, int b)
{
  return !!a != !!b;
}

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

SS>>Логический xor — это оператор !=
SS>>Xor = x1!=x2

SWW>При условии что x1 и x2 — это bool, а не BOOL

А как насчет этого

inline bool xor(int a, int b)
{
   return !!a != !!b;
}

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

SS>Здравствуйте, Евгений Коробко, Вы писали:

ЕК>>Я жуе не говорю про логический xor.
ЕК>>Конечно, можно сделать
ЕК>>inline bool Xor(bool x1,bool x2)
ЕК>>{
ЕК>> return (x1&&(!x2))||(x2&&(!x1))
ЕК>>}
ЕК>>Но, согласитель, некрасиво. И вряд ли эффективно.

SS>Логический xor — это оператор !=
SS>Xor = x1!=x2

Я бы предпочел написать
BOOL x1, x2;
{...}
BOOL bTest = ( (x1!=0) ^ (x2!=0) );
BOOL bTest = ( (!x1) ^ (!x2) );
хотя все равно убого. Надо спросить у Страуструпа, почему нет ^^ . Давайте спросим?

Д>А как насчет этого
Д>

Д>inline bool xor(int a, int b)
Д>{
Д>   return !!a != !!b;
Д>}
Д>

Раз пошла такая пьянка, то можно и проще:

inline bool xor(int a, int b)
{
   return !a != !b;
}

Здравствуйте, Андрей Тарасевич, Вы писали:

АТ>А вот операторов '&&=' и '||=' действительно не хватает.

Я думаю, ничего страшного в их отсутствии нет. Не помню, чтобы они хоть раз понадобились.

Ведь вот еще встает какой вопрос: в отношении этих операторов должно ли действовать правило сокращенного вычисления? Если да, то получается:

x ||= y;

эквивалентно следующему:

if (!x)
    x = y;

Если это применяется в некоторой последовательности

x ||= y1;
x ||= y2;
x ||= y3;
...
x ||= yn;

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

Да и вообще запись неясна...

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

Д>>А как насчет этого
Д>>

Д>>inline bool xor(int a, int b)
Д>>{
Д>>   return !!a != !!b;
Д>>}
Д>>

SWW>Раз пошла такая пьянка, то можно и проще:
SWW>

SWW>inline bool xor(int a, int b)
SWW>{
SWW>   return !a != !b;
SWW>}
SWW>

Ну пьянка или нет, я хотел показать, как BOOL(и не только BOOL) можно преобразовать к bool,
а с точки зрения оптимальности твое лучше. Хотя я не знаю, как все это дело компилер обрабатывает...

Здравствуйте, Евгений Коробко, Вы писали:

ЕК>Здравствуйте, Lorenzo_LAMAS, Вы писали:

L_L>>А для чего, если не секрет, они Вам нужны? С примерами пожалуйста.

ЕК>Странный вопрос. Каждый бинарный оператор имеет соответствующий оператор с присваиванием. Исключение составляет лишь логические операторы || и &&.
ЕК>Логическое XOR — это, по-моему, вообще очевидно.
ЕК>Пример:

ЕК>bool res=true;
ЕК>for(int i=0;i<Size;i++) res&&=test_object(objs[i]);

ЕК>Устроит?

ЕК>Эти операторы (|| и &&) нужны для того же, для чего и +=,-=,*=,/=,<<=,>>=,&=,|=,^=. Для большей эстетичности, читаемости и оптимизации.

ЕК>Убедил?


Бред какой-то...
Зачем проболжать вычесления, если res обнулился?
Тем более, что test_object(objs[i]) может быть достаточно трудоемкой.

Я на практике никода не встречался с такой ситуацией, что нужен этот оператор...

S> А сама функция должна внутри содержать неоходимые проверки флагов. Причём ситуация когда пишется:

S>

S>  bool res = F1();
S>  res = res && F2();
S>  res = res || F3();
S>

S> Это уже плохо спланированная программа.

Интересный способ доказательства: придумать заведомо бесполезный пример и, убедительно доказав его бесполезность, сделать вывод о бесполезности операторов ||= и &&=

Вообще-то значение res может понадобиться после первой строки, но до второй.

Ну, ладно, напишем
for(int i=0;i<Size&&res;i++) res&&=test(...);


Оценить

Оператор != не подходит потому, что в С++ есть неявное преобразование из int в bool.
Отличие xor от bool должно быть в том, что xor принудительно приводит операнды к bool.

int a=2,b=4;

a xor b == false (a и b приводятся к true)
a!=b == true

Т.е.
#define xor(a,b) (static cast<bool>(a)!=static cast<bool>(b))

Но хотелось бы в форме оператора.
Ну и опять-таки, ^^=...

А про то, что можно обойтись условными операторами и пр. — когда можно, а когда и нет. Знаете, есть дискретная математика, всякие так КНФ, ДНФ и пр. самые настоящие вычисления, только не с числами, а с булевскими переменными.

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

S>любому читающему будет понятен смысл данного утверждения. А о коде приведенном выше сказать однозначно нельзя какой смылс заложен в это условие.
S>Хотя иногда возникает необходимость раздробить условие на составные части (если он сильно длинное), но лично я все логические проверки провожу в блоке if (). Так для меня нагляднее и ясно читается мысль

А что если нам это нужно для хранения успешности выполнения операций?
в этом коде:

if ((F1() && F2()) || F3())

Не будет выполненна F2 если F1 возвратит 0 , и не будет выполнена F3 если 1 возвратят F1 и F2 , а в коде:

  bool res = F1();
  res = F2() && res;
  res = F3() || res;

в любом случае будут выполненны все 3 операции

Здравствуйте, Евгений Коробко, Вы писали:



ЕК>Ну, ладно, напишем
ЕК>for(int i=0;i<Size&&res;i++) res&&=test(...);


ЕК> Оценить

Я не согласен.
Здесь можно обойтись и так:

for(int i=0; i<Size && test(...); ++i)
  ;

Ведь новый шаг делается, при условии, что все предыдущие вызовы test() были верными.

Или в крайнем случае можно поставить if()
А для того, чтобы проверить сохранить результат можно пользоваться так:

res = i == size;

Здравствуйте, Доброжелатель, Вы писали:


Д>Я не согласен.
Д>Здесь можно обойтись и так:
Д>

Д>for(int i=0; i<Size && test(...); ++i)
Д>  ;
Д>

Д>Ведь новый шаг делается, при условии, что все предыдущие вызовы test() были верными.

Д>Или в крайнем случае можно поставить if()
Д>А для того, чтобы проверить сохранить результат можно пользоваться так:
Д>

Д>res = i == size;
Д>

Использование переменной цикла после цикла — не совсем хорошо.
Впрочем, возможно, это действительно не самый лучший пример.

Здравствуйте, Аноним, Вы писали:

А>Могу предложить такой вариант...
А>

А>inline bool xor(bool a, bool b)
А>{
А>  return a != b;
А>}
А>

А>или
А>

А>inline bool xor(int a, int b)
А>{
А>  return !!a != !!b;
А>}
А>

Конечно, можно. Вопрос в том, почему этого нет в С++. Мне кажется, что былобы очень логично. И не водно ни одного аргумента против таких операторов. Это как если бы long не мог быть unsigned или нельзя было бы делать указатели на double... Вот почему нет оператора возведения в степерь (**) — понятно. Понятно, почему нельзя перегружать оператор точка (.) и нельзя добавлять новые операторы. А вот отсутствие оператора логического xor и операторов &&= и ||= непонятно. Они нужны хотя бы для симметрии.

Можно вообще класс написать
class Bool
{
...
};
и в нём перегрузить все операторы а также &=,|=,^=, сделать конструкторы и оператор преобразования к bool.

Здравствуйте, Доброжелатель, Вы писали:

ЕК>>Ну, ладно, напишем
ЕК>>for(int i=0;i<Size&&res;i++) res&&=test(...);

Д>Здесь можно обойтись и так:

Д>for(int i=0; i<Size && test(...); ++i)
Д>  ;

Д>Ведь новый шаг делается, при условии, что все предыдущие вызовы test() были верными.

Да, нет -- можно даже меньше изменить, и будет видно, что "&&=" не нужен:

for(int i=0;i<Size&&res;i++) res=test(...);

Здравствуйте, Евгений Коробко, Вы писали:

ЕК>Использование переменной цикла после цикла — не совсем хорошо.
Нет это совсем плохо ибо запрещено стандартом.

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

WH>Здравствуйте, Евгений Коробко, Вы писали:

ЕК>>Использование переменной цикла после цикла — не совсем хорошо.
WH>Нет это совсем плохо ибо запрещено стандартом.

Да возможно... Но я лично пользуюсь VS 6.0, и Microsoft считает, что для совместимости
этот пункт можно обойти...