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

Question

Today at work we came across the following code (some of you might recognize it):

#define GET_VAL( val, type ) \
    {                                                   \
        ASSERT( ( pIP + sizeof(type) ) <= pMethodEnd ); \
        val = ( *((type *&)(pIP))++ );                  \
    }

Basically we have a byte array and a pointer. The macro returns a reference to a variable of type and advance the pointer to the end of that variable.

It reminded me of the several times that I needed to "think like a parser" in order to understand C++ code.

Do you know of other code examples that caused you to stop and read it several times till you managed to grasp what it was suppose to do?

Answer 1

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 2

I know it's C and not C++ but there is always the the International Obfuscated C Code Contest. I have seen some code there that would make your head spin.

Answer 3

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 4

Binary shifts confuses me all the time:

An example from java.util.concurrent.ConcurrentHashMap:

return ((h << 7) - h + (h >>> 9) + (h >>> 17))

Answer 5

This was on reddit recently http://www.xs4all.nl/~weegen/eelis/analogliterals.xhtml

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

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.

Answer 7

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

Answer 8

Duff's Device (http://en.wikipedia.org/wiki/Duff%27s_device) give me nightmares:

strcpy(to, from, count)
char *to, *from;
int count;
{
    int n = (count + 7) / 8;
    switch (count % 8) {
    case 0: do { *to = *from++;
    case 7:      *to = *from++;
    case 6:      *to = *from++;
    case 5:      *to = *from++;
    case 4:      *to = *from++;
    case 3:      *to = *from++;
    case 2:      *to = *from++;
    case 1:      *to = *from++;
               } while (--n > 0);
    }
}

Answer 9

Most Boost stuff - the template metaprogramming is bad enough, but when you factor in the workarounds necessary to get it to work on some compilers (*coughborlandcough*), it gets pretty ridiculous. Just try to understand Boost.Bind. Just try.

Answer 10

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 11

Anything prefixed with:

/* You are not expected to understand this */