¿Por qué no hay operador || = en C/C++?

Question

duplicados posibles:
&&= and ||= operators

Véase el título. Esta pregunta puede ampliarse para incluir todos los operadores lógicos + de asignación. Para aclarar: no estoy hablando del operador | =.

Otro ejemplo: & & =

Gracias.

Ejemplo:

 
bool result = false; 

// Today 
result = result || my_test1(); 
// Do stuff 
result = result || my_test2(); 

// In my imagination only... 
result ||= my_test1(); 
// Do stuff 
result ||= my_test2(); 

Answer 1

En una conjetura, ya que sólo tendría sentido para Bools, que eran tarde a la fiesta

Incluso si Bools habían existido en el inicio de estos operadores serían de uso limitado, ya que sin efectos secundarios serían idénticos a |= y &= con operandos booleanos, por lo que el único uso sería atrapar pasando un no bool por accidente.

Si los operadores propuestos son también cortocircuitos (no excesivo como || y && son para este tipo incorporado), entonces también tiene una justificación adicional para ellos en la presencia de efectos secundarios.

La única otra posible razón que puedo pensar para permitirlos sería si simplificara significativamente el análisis/compilación del lenguaje, sin embargo, probablemente no sea el caso dado que no tienen sentido para los tipos que no son bool.

En última instancia, no están en el idioma porque nadie se ha preocupado lo suficiente como para ponerlos en el idioma, por lo que podemos concluir que ninguna de estas justificaciones es suficiente para justificar el costo de presentar una propuesta, implementando la característica.

Answer 2

Porque no tendrían sentido. La definición de x op= y es x = x op y, excepto que x solo se evalúa una vez. ¿Qué significa esto con un operador en cortocircuito, que convierte cada uno de sus operandos (si los evalúa) en bool? El equivalente de ||= podría ser algo como:

if (!x) 
    x = y; 

que es ciertamente diferente de la interpretación de otra op=.

Answer 3

No hay una buena razón lógica ... solo presiones históricas para las características.

Los operadores lógicos no están normalmente disponibles como códigos de operación de una sola CPU, por lo que no son tan baratos o fundamentales como sus contrapartes bit a bit. Un XOR lógico sería bueno también, quizás ^^, luego ^^=.

Aún así, la proliferación de operadores hace que sea cada vez más doloroso crear tipos definidos por el usuario con una semántica integrada, y hay pocas ganancias en el mundo real. Todavía me gustaría verlos; estos operadores existen en algunos otros idiomas, como Ruby, y los he encontrado prácticos y expresivos.

Answer 4

Porque su modus operandi es muy diferente.

mirada a las firmas: existen

operadores

T operator+(T,T); 
T& T::operator+=(T); 

T operator*(T,T); 
T& T::operator*=(T); 

bool operator&&(T,T); 
??? 

compuestos para los operadores que devuelven el mismo tipo de argumento, los && y || operadores devuelven un valor booleano (o al menos, se espera que a), y por lo tanto no tiene sentido crear una versión compuesta, excepto quizás para booleanos solo.