Thread: Good examples/uses of bitwise operations?

I don't recall having used it myself and there isn't really the bitwise aspect to it, but in a situation where you want to write if (foo() && bar()) such that both functions will always be called, changing the && to & may be an applicable solution.

Originally Posted by MutantJohn

I'ma just go ahead and make the assumption that bitwise operations are the fastest.

Note that a compiler may optimise code that does not use bitwise operations to use bitwise operations if they are common cases such that the change should result in faster code. Things like multiplying/dividing by a constant that is a power of two to become a bitwise shift, or changing n % 2 to n & 1 comes to mind. Likewise, unless you intend obfuscated code, there would be no advantage in using SirPrattlepod's example over a direct assignment of 0, even if somehow the translation without optimisation would have resulted in faster code: assignment of 0 should be so common that any sane compiler author would make the compiler do it even without any optimisations turned on.

It should be made clear that none of the above tricks will gain you anything. It's best to write clear, idiomatic code and let the compiler perform the optimizations since they may be different for different platforms.

Generally, the stuff that Adak mentioned are not mere tricks but legitimate techniques. nonpuz's example of bitwise flags is a well known idiom that is used in the C standard library.

I'd say that my example is something of a trick since it runs the risk that a reader may mistake your intention, but then no compiler can "optimise" the && to an & since it could change the result of the code (and isn't an optimisation anyway).

I should have specified which ones I would call useless tricks:

Code:

x <<= 1;  // if what you mean is x *= 2;

x ^= x;   // instead of x = 0;

a ^= b;
b ^= a;
a ^= b;

Using & as a non-short-circuiting && is also a trick, since you can just write:

Code:

int fooval = foo();
if (bar() && fooval)

and the compiler can optimize fooval away.

The other mentioned techniques are obviously valid and useful.

Originally Posted by rcgldr

a classic way to swap values between two variables without using a temp variable:

a ^= b;
b ^= a;
a ^= b;

Yeh and then you fall on your face when at some time the a == b initially...
For me - this is classic example how NOT to swap variables

You can use bit logic like this to create any pattern of digits you want. Here rcgldr uses unsigned int64 data types, to work on.

vData[] is an array of 100 these unsigned int64's (typedef'd to use the handle of UI64)

rand() returns a smaller int, so it has to be cast to UI64's size.

Code:

	for(j =	0; j < 100; j++){
		i  = (((UI64)((rand()>>4) &	0xff))<< 0);
		i += (((UI64)((rand()>>4) &	0xff))<< 8);
		i += (((UI64)((rand()>>4) &	0xff))<<16);
		i += (((UI64)((rand()>>4) &	0xff))<<24);
		i += (((UI64)((rand()>>4) &	0xff))<<32);
		i += (((UI64)((rand()>>4) &	0xff))<<40);
		i += (((UI64)((rand()>>4) &	0xff))<<48);
		i += (((UI64)((rand()>>4) &	0xff))<<56);

		
         vData[j] = i;

         if(j<100)
             printf("j: %llu   i: %llu vData[j]: %llu\n",j,i,vData[j]); 

    }

More bit twiddling:
http://graphics.stanford.edu/~seander/bithacks.html