operador bool ++ e -

Hoje, ao escrever algum código Visual C ++, encontrei algo que me surpreendeu. Parece que C ++ suporta ++ (incremento) para bool, mas não - (decremento). É apenas uma decisão aleatória ou há algum motivo por trás disso?

Isso compila:

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

Isso não:

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

Ele vem da história do uso de valores inteiros como booleanos.

Se xfor um int, mas estou usando-o como um booleano, if(x)...então incrementar significará que qualquer que seja o seu valor verdade antes da operação, terá um valor verdade truedepois (barrando o estouro).

No entanto, é impossível prever o resultado de --determinado conhecimento apenas do valor de verdade de x, já que poderia resultar em false(se o valor integral for 1) ou true(se o valor integral for qualquer outra coisa - notavelmente isso inclui 0 [ false] e 2 ou mais [ true]).

Então, como um atalho ++funcionou, e --não funcionou .

++ é permitido em bools para compatibilidade com isso, mas seu uso está obsoleto no padrão.

Isso pressupõe que eu use apenasx como booleano, o que significa que o estouro não pode acontecer até que eu tenha feito o ++suficiente para causar um estouro por conta própria. Mesmo com char como o tipo usado e CHAR_BITSalgo baixo como 5, isso é 32 vezes antes que isso não funcione mais (isso ainda é um argumento suficiente para ser uma prática ruim, não estou defendendo a prática, apenas explicando por que funciona) para 32 bits, inté claro que teríamos de usar ++2 ^ 32 vezes antes que isso fosse um problema. Com --embora, ele só resultará em falsese eu começar com um valor de 1 para true, ou começar com 0 e usar ++precisamente uma vez antes.

Isso é diferente se começarmos com um valor que é apenas alguns abaixo de 0. Na verdade, nesse caso, podemos querer ++resultar no falsevalor eventualmente, como em:

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

No entanto, este exemplo trata xcomo um inttodo, exceto o condicional, portanto, é equivalente a:

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

O que é diferente de usar apenas xcomo booleano.

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

5.2.6-2

O operando de postfix - é decrementado analogamente ao operador postfix ++, exceto que o operando não deve ser do tipo bool. [Nota: Para incremento e decremento do prefixo, consulte 5.3.2. ]

E sem surpresa ...

5.3.2-2

O operando do prefixo - é modificado subtraindo 1. O operando não deve ser do tipo bool. Os requisitos do operando de prefixo - e as propriedades de seu resultado são as mesmas do prefixo ++. [Nota: Para incremento e decremento pós-fixados, consulte 5.2.6. ]

Além disso, 5.6.2-1 e 5.3.2-1 mencionam que ++ para bools deve ser verdadeiro e o Anexo D-1 diz que ++ para bools está obsoleto.

Por razões históricas, isso foi apoiado. Mas observe que ... O uso de um operando do tipo bool com o operador ++ está obsoleto, consulte a Seção 5.3.2 no Padrão C ++ (n3092)

5.3.2 Incremento e decremento [expr.pre.incr]

• O operando do prefixo ++ é modificado pela adição de 1 ou definido como verdadeiro se for bool (esse uso está obsoleto). O operando deve ser um valor modificável. O tipo de operando deve obrigatoriamente ser um tipo aritmético ou um ponteiro para um tipo de objeto completamente definido. O resultado é o operando atualizado; é um lvalue e é um campo de bits se o operando for um campo de bits. Se x não for do tipo bool, a expressão ++ x é equivalente ax + = 1 [Observação: consulte as discussões sobre adição (5.7) e operadores de atribuição (5.17) para obter informações sobre conversões. —Enviar nota]
• O operando do prefixo - é modificado subtraindo 1. O operando não deve ser do tipo bool. Os requisitos do operando de prefixo - e as propriedades de seu resultado são as mesmas do prefixo ++.

• Com os padrões antigos (C ++ 98), não é um erro.
• Com os novos padrões, incrementar um booleano está obsoleto. (C ++ 11)
• Você pode usar a incrementação em um booleano até C ++ 17.