What is the most hard to understand piece of C++ code you know? [closed]

Answer 1

This is well known but still impressive way to swap two integers without creating temp variable:

// a^=b^=a^=b;     // int a and int b will be swapped
// Technically undefined behavior as variable may only 
// be assined once within the same statement.
// 
// But this can be written correctly like this.
// Which still looks cool and unreadable ;-)

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

Answer 2

C, but present in C++, I find the comma operator really obfuscates code, take this...

ihi = y[0]>y[1] ? (inhi=1,0) : (inhi=0,1);

Terse and quite elegant, but very easy to miss or misunderstand.

Answer 3

This was on reddit recently http://www.eelis.net/C++/analogliterals.xhtml

 assert((o-----o
        |     !
        !     !
        !     !
        !     !
        o-----o ).area == ( o---------o
                            |         !
                            !         !
                            o---------o ).area );

Answer 4

The inverse square root implementation in Quake 3:

float InvSqrt (float x){
    float xhalf = 0.5f*x;
    int i = *(int*)&x;
    i = 0x5f3759df - (i>>1);
    x = *(float*)&i;
    x = x*(1.5f - xhalf*x*x);
    return x;
}

Update: How this works (thanks ryan_s)

Answer 5

I vote for some black-magic-hackerish template metaprogramming (unfortunately don't have any on hand to post it).

Answer 6

unsigned int reverse(register unsigned int x)
{
 x = (((x & 0xaaaaaaaa) >> 1) | ((x & 0x55555555) << 1));
 x = (((x & 0xcccccccc) >> 2) | ((x & 0x33333333) << 2));
 x = (((x & 0xf0f0f0f0) >> 4) | ((x & 0x0f0f0f0f) << 4));
 x = (((x & 0xff00ff00) >> 8) | ((x & 0x00ff00ff) << 8));
 return((x >> 16) | (x << 16));
}

Reverses the order of the bits in an int.