Did you know this was valid C++

#include <iostream>
using std::cout;
using std::endl;

int main ()
{
  bool b = false;
  cout << b << endl;
  b++;
  cout << b << endl;
  b++;
  cout << b << endl;
  return 0;
}

You can call increment on false to get true, and increment on true to get ... true.
And if you replace ++ with -- , that's not valid C++.

I only found this out just today; it's been slated to be deprecated in C++17 (link) Enjoy while you can!

Is b++ just the same as b = true? Anyone tested it or looked at the assembly?

By the way, negation would be b ^= 1. Unless C++ disallows it, of course

With the postfix operators you have to increment and print them in two different statements, otherwise you get the original value

But it looks like bools are limited to be either 0 or 1. I guess b + 1 would be 1?

By the way, what compiler version did you use?

Well, looking at it from C it makes sense - there bool is the same as int and anything except zero means true. So if x is 1 and you do x++ it gets 2, which is still true.

It is stupid that they allowed ++ for bool in C++, but so are 1000 other things in C++, so I don't see anything special here

Why not x-- then?

As it is, you can flip false to true, or true to true, but not true to false. I would think the operators should be symmetrical, or not at all.

I used MSVC, clang and gcc (not sure of the latest versions but all recent)

I suppose if you view bool as a one-bit arithmetic type then incrementing true is an overflow and that results in undefined behaviour - so the value could be anything.

And I suppose if you incremented something N times and decremented it N times you might expect to be back where you started, which can't be guaranteed for bool so they disabled '--'.

Maybe there was some reason for it back when they wrote the spec and maybe it just slipped through the net?

[edit] The fact that it's post increment gives it one possible use, though it's not hard to find alternatives:

void printlist(int n) {
 bool comma = false;
 for (int i = 0; i < n; ++i) {
  if (comma++) {
   cout << ',';
  }
  cout << i;
 }
}

The original example was here using C++ ranged for statement which makes a bit more sense.

I'm of the opinion that if a sensible meaning can be defined for an operator then it should be. I like being able to make code terse and operators are the best way to achieve that from the language or a global library. I don't see this as a problem at all, as long as the results are defined. If anything, it's a WTF to me that you cannot decrement. It's no surprise to most of us that a boolean type is typically represented by a 0/^0/!0 byte or bit. And we all understand what the result would be of incrementing those. It may not entirely make sense logically, but at the same time a useful meaning can be applied to and derived from it.

I compiled this as C++ in VS 2015, no optimizations:

void incbool(bool b)
{
  b++;
}

And got this:

?incbool@@YAX_N@Z (void __cdecl incbool(bool)):
  00000000: 55                 push        ebp
  00000001: 8B EC              mov         ebp,esp
  00000003: 51                 push        ecx
  00000004: 8A 45 08           mov         al,byte ptr [ebp+8]
  00000007: 88 45 FF           mov         byte ptr [ebp-1],al
  0000000A: C6 45 08 01        mov         byte ptr [ebp+8],1
  0000000E: 8B E5              mov         esp,ebp
  00000010: 5D                 pop         ebp
  00000011: C3                 ret

It's just copied, and then set to true.

Yeah, I get get same result in VS 2015. Only the name mangling of the function changes, the assembly is otherwise identical. I guess VS finally supports C99 bool, then.

Yeah

{"name":"636x460design_01.jpg","src":"\/\/djungxnpq2nug.cloudfront.net\/image\/cache\/4\/8\/48bed991ae72aac26032315a4ba6c62b.jpg","w":636,"h":460,"tn":"\/\/djungxnpq2nug.cloudfront.net\/image\/cache\/4\/8\/48bed991ae72aac26032315a4ba6c62b"}

You should be careful with that kind of thing. Many simple operations require only one cycle on the CPU to do. And if you are comparing ints to bools on a PC (32 or 64 bits), you are probably comparing 32-bit types to 8-bit types. Which one is faster depends on what you do with. You could be comparing an operation to one that's different in either implementation, purpose, or both. Just saying

Since ++ just copies it and sets it to true, then there's no reason not to include -- to copy and set to false.

Note: my actual position is that the operators should not be used at all on bool.

All of that's probably true

It has to copy, that's the whole point of postincrement.

Fuck Matthew Leverton, just fuck him.