type - c++ incremento y decremento

bool operator++ y-

Question

Hoy mientras escribía código de Visual C ++ me encontré con algo que me sorprendió. Parece que C ++ admite ++ (incremento) para bool, pero no - (decremento). ¿Es solo una decisión aleatoria, o hay alguna razón detrás de esto?

Esto compila:

static HMODULE hMod = NULL;
static bool once = false;
if (!once++)
    hMod = LoadLibrary("xxx");

Esto no lo hace:

static HMODULE hMod = NULL;
static bool once = true;
if (once--)
    hMod = LoadLibrary("xxx");

Answer 1

Debido a razones históricas esto fue apoyado. Pero tenga en cuenta que ... El uso de un operando de tipo bool con el operador ++ está en desuso, vea la Sección 5.3.2 en el Estándar C ++ (n3092)

5.3.2 Incremento y decremento [expr.pre.incr]

• El operando del prefijo ++ se modifica agregando 1 o se establece en verdadero si es bool (este uso está en desuso). El operando debe ser un valor l modificable. El tipo del operando debe ser un tipo aritmético o un puntero a un tipo de objeto completamente definido. El resultado es el operando actualizado; es un valor l, y es un campo de bits si el operando es un campo de bits. Si x no es de tipo bool, la expresión ++ x es equivalente a x + = 1 [Nota: consulte las discusiones sobre suma (5.7) y operadores de asignación (5.17) para obtener información sobre las conversiones. -finalizar nota]
• El operando de prefijo - se modifica restando 1. El operando no debe ser de tipo bool. Los requisitos en el operando de prefijo - y las propiedades de su resultado son, por lo demás, los mismos que los del prefijo ++.

Answer 2

Viene de la historia de usar valores enteros como booleanos.

Si x es un int , pero lo estoy usando como un booleano como if(x)... entonces incrementar significa que sea cual sea su valor de verdad antes de la operación, tendrá un valor de true de true después de él (salvo desbordamiento) )

Sin embargo, es imposible predecir el resultado de -- dado conocimiento solo del valor de verdad de x , ya que podría resultar en false (si el valor integral es 1) o true (si el valor integral es cualquier otra cosa, notablemente esto incluye 0 [ false ] y 2 o más [ true ]).

Entonces, como una mano corta ++ trabajó, y -- no lo hizo.

++ está permitido en bools para compatibilidad con esto, pero su uso está obsoleto en el estándar.

Esto supone que solo uso x como booleano, lo que significa que el desbordamiento no puede ocurrir hasta que haya hecho ++ frecuencia suficiente como para causar un desbordamiento por sí mismo. Incluso con CHAR como el tipo usado y CHAR_BITS algo bajo como 5, eso es 32 veces antes de que esto no funcione más (eso sigue siendo argumento suficiente para que sea una mala práctica, no estoy defendiendo la práctica, solo explicando por qué funciona ) para un int 32 bits, por supuesto tendríamos que usar ++ 2 ^ 32 veces antes de que esto sea un problema. Con -- aunque solo resultará en false si comencé con un valor de 1 para true , o comencé con 0 y usé ++ exactamente una vez antes.

Esto es diferente si comenzamos con un valor que es solo unos pocos debajo de 0. De hecho, en tal caso podríamos querer que ++ como resultado el valor false eventualmente tal como en:

int x = -5;
while(++x)
  doSomething(x);

Sin embargo, este ejemplo trata x como un int todas partes, excepto el condicional, por lo que es equivalente a:

int x = -5;
while(++x != 0)
  doSomething(x);

Lo cual es diferente a solo usar x como booleano.

Answer 3

ANSI ISO IEC 14882 2003 (c ++ 03):

5.2.6-2

El operando de postfix - se decrementa análogamente al operador postfix ++, excepto que el operando no debe ser de tipo bool. [Nota: para el incremento y la disminución del prefijo, ver 5.3.2. ]

Y como era de esperar ...

5.3.2-2

El operando de prefijo - se modifica restando 1. El operando no debe ser de tipo bool. Los requisitos en el operando de prefijo - y las propiedades de su resultado son, por lo demás, los mismos que los del prefijo ++. [Nota: para el incremento y la disminución de posfijo, vea 5.2.6. ]

También el 5.6.2-1 y el 5.3.2-1 mencionan que ++ para los bools será verdadero y el Anexo D-1 dice que ++ en bools está en desuso.

Answer 4

• Con los estándares anteriores (C ++ 98) no es un error.
• Con los nuevos estándares que incrementan un valor booleano está en desuso. (C ++ 11)
• Puede usar incrementos en un booleano hasta C ++ 17.