Re[12]: Операторы в С++ - C/C++

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

ЕК>Есть какое-нибудь логическое объяснение, почему в С++ отсутствуют операторы:
ЕК> &&=
ЕК> ||=
ЕК> логическое XOR (^^ или что-то подобное)
ЕК>Как-то несимметрично получается...

Что касается логического XOR, то его отсутствие объясняется одним принципиальным отличием операции XOR от операций AND и OR — он не допускает сокращенного вычисления. Без сокращенного вычисления логический XOR быть с известной долей осторожности заменен оператором '!='. XOR это фактически и ест логическое '!='.

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

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

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

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

Есть какое-нибудь логическое объяснение, почему в С++ отсутствуют операторы:
&&=
||=
логическое XOR (^^ или что-то подобное)
Как-то несимметрично получается...

ЕК>А что касается "можно обойтись без этого" — понятное дело. Можно обойтись машиной Тьюринга.

Да дело даже не в машине Тьюринга. Просто грамотные программисты всегда пишут так:


  if(IsFileOpen()){...}
  if(IsWindow()){...}
  if(Is...){}

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


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

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

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

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

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

Оценить

Posted via RSDN NNTP Server 1.6 beta

Здравствуйте, 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 операции

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

ЕК>отсутствие оператора логического xor и операторов &&= и ||= непонятно. Они нужны хотя бы для симметрии.

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

Забавно, конечно, создавать класс Bool, но это всего лишь еще один новый "велосипед"...
Гораздо проще обойтись и обычными операторами.

А симметрия, наверное нарушена. Но я не знаю никого, кто бы от этого пострадал...

Если так судить, то и штрих Шеффера надо добавлять и стрелку Пирса...
Они все легко заменяемы.

Удалено избыточное цитирование. -- ПК.

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

S>Не городите ерунды. b ||= true равно true, b ||=false равно b. Во вторыхб b &&= false равно false и т.д.. Кому это надо писать эту чушь???

а
x ||= y и x &&= y

чему будет равно?

Ed.ward

... << RSDN@Home 1.0 beta 7a >>

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

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

А>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.

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

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

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

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

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

Устроит?

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

Убедил?

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

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

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

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

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

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

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

EW>x ||= y и x &&= y

EW>чему будет равно?

А зачем это надо??? Для каких целей? Что этим преследуется?

S>А зачем это надо??? Для каких целей? Что этим преследуется?

Что значит "зачем"? Ты не видишь смысла в выражениях x = x || y и x = x && y ?
Вообще-то логические выражения бывают и посложнее.

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

EW>x ||= y и x &&= y

EW>чему будет равно?

S>А зачем это надо??? Для каких целей? Что этим преследуется?

например так

bool result = false;
result &&= First();
result ||= Second();
result &&= Third();

if( result )
{
// ...
}

Соотвественно First, Second и Third функции анализирующие, скажем состояние объекта, ну и возвращающие значения типа bool.

Ed.ward

... << RSDN@Home 1.0 beta 7a >>

EW>например так

EW>

EW>bool result = false;
EW>result &&= First();
EW>result ||= Second();
EW>result &&= Third();

EW>if( result )
EW>{
EW>// ...
EW>}
EW>

А чем это не устраивает:

int result = false;
result &= First();
result |= Second();
result &= Third();

if( result )
{
// ...
}

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

S>А чем это не устраивает:

S>[ccode]
S>int result = false;
S>result &= First();
S>result |= Second();
S>result &= Third();

Не надо путать битовые операции и логические.

2 & 4 == false (0)
2 && 4 == true

Это разные операции.

ЕК>Не надо путать битовые операции и логические.

ЕК>2 & 4 == false (0)
ЕК>2 && 4 == true

ЕК>Это разные операции.

Да, правда, но функции должны возвращать 1 или 0. А вообще всё это обходится так или иначе. И с использованием типа bool и без.

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

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

S>>А чем это не устраивает:

S>>[ccode]
S>>int result = false;
S>>result &= First();
S>>result |= Second();
S>>result &= Third();

ЕК>Не надо путать битовые операции и логические.

ЕК>2 & 4 == false (0)
ЕК>2 && 4 == true

ЕК>Это разные операции.

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

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

конечно, bool+bool смысла не имеет. А вот bool && bool ещё как имеет.
Дело в том, что из С унаследована роль int как bool. Это приводит к некоторой путанице.

Это — не расширение С++. Вообще, когда я столкнулся с отсутствием этих операторов, я был удивлён.

А что касается "можно обойтись без этого" — понятное дело. Можно обойтись машиной Тьюринга.

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

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

S>


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

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

Поддержу предыдущего оратора:

в коде приведенном выше неясно как должны выполняться логические условия (здесь правда можно сказать что это сила привычки и т.д.):

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

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

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) );
хотя все равно убого. Надо спросить у Страуструпа, почему нет ^^ . Давайте спросим?

... << RSDN@Home 1.0 beta 6a >>

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

Д>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 может понадобиться после первой строки, но до второй.

Оператор != не подходит потому, что в С++ есть неявное преобразование из 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))

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

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

Posted via RSDN NNTP Server 1.6 beta

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

ЕК>Ну, ладно, напишем
ЕК>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;
Д>

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

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

ЕК>>Ну, ладно, напишем
ЕК>>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(...);

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

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

... << RSDN@Home 1.0 beta 6a >>

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

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

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

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

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

ЕК>Оператор != не подходит потому, что в С++ есть неявное преобразование из 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))

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

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

Да, но я не предлагаю сравнивать на неравенство два целых числа.
Я в своем примере писал !!а.
А если говорить о красивости... Не так часто сравниваются два логических выражния на равенство или неравенство, тем более, если имеет место неявное преобразование типов.

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

Д>Если так судить, то и штрих Шеффера надо добавлять и стрелку Пирса...
Д>Они все легко заменяемы.

Импликацию , обратную импликацию , запрет , повтор...

Удалено избыточное цитирование. -- ПК.

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

Д>>А симметрия, наверное нарушена. Но я не знаю никого, кто бы от этого пострадал...

Да, собственно, изначально вопрос был не в том, как обойтись без этих операторов (это очевидно).
Вопрос был в том, а почему, собственно, их нет. Лично мне их отсутствие кажется нелогичным.

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

ЕК>Да, собственно, изначально вопрос был не в том, как обойтись без этих операторов (это очевидно).
ЕК>Вопрос был в том, а почему, собственно, их нет. Лично мне их отсутствие кажется нелогичным.

нелогическим

насколько я помню,самая моя первая программа нуждалась именно в ^^ и ^^=

	От:	sercher
	Дата:	10.06.03 12:53
	Оценка:	+1 -3

	От:	Андрей Тарасевич
	Дата:	10.06.03 20:40
	Оценка:	7 (2)

	От:	SergeyS
	Дата:	10.06.03 15:51
	Оценка:	6 (2)

	От:	Евгений Коробко
	Дата:	10.06.03 12:07
	Оценка:	-1

	От:	sercher
	Дата:	11.06.03 05:13
	Оценка:	-2

	От:	Доброжелатель
	Дата:	13.06.03 13:31
	Оценка:	1 (1)

	От:	Михаил Трухманов
	Дата:	13.06.03 10:30
	Оценка: