Comments on Daniel's Software Blog: C Language Quirks

amazing concepts of c guys... watch these on http:...

2011-09-04T02:28:17.647-07:00

amazing concepts of c guys...
watch these on http://technoease.com/453/programming/c-programming/control-instructions-i/#more-453

also, the % operand acts differently between proce...

2011-02-09T04:20:32.826-08:00

also, the % operand acts differently between processors... try % in a negative number. like -10 % 360 , would contain 350 on some processors, and -10 on others...

By the way, this works fine in GCC. Looking at th...

2010-05-20T11:35:51.159-07:00

By the way, this works fine in GCC. Looking at the preprocessor output, it looks like the GCC preprocessor actively prevents generation of '/*':

inverse(*d)

becomes:

1/ *a

Which raises the challenge, can one defeat GCC's preprocessor so as to generate the original, 'bad' behavior...

Variation on one of your examples above: #define ...

2010-05-19T20:55:51.556-07:00

Variation on one of your examples above:

#define inverse(a) 1.0/a

double d[2] = { 2.0, 2.0 };

cout << inverse(*d) << ", " /* print both */
<< inverse(d[1]) << endl; /* versions */

This will print "10.5".

Thanks for great comments. I am aware that the ove...

2010-05-10T20:00:21.727-07:00

Thanks for great comments. I am aware that the overflow example is a bit misleading and the behavior with integers is not fully described. I wanted to show the different behavior of a 'simple' type change but I realize after reading comments that the initial behavior of the integers probably are more interesting.

The inverse macro example is also more interesting than I first thought and if someone have some more insight I'd be happy to learn more. I tested the code on several different compilers, and some remove the comments before macro expansion and some after. Interesting is that even two different versions of gcc got different result.

Nice post. About the "Bitwise Operator Mista...

2010-05-07T04:05:47.795-07:00

Nice post.

About the "Bitwise Operator Mistakes". Smart compiler (clang for instance) are able to detect this kind of mistake.

For example, trying to compile the printBits() function, it will output a couple of warning like the following one:

"warning: & has lower precedence than !=; != will be evaluated first "

The bug with the inverse macro can only happen on ...

2010-05-07T00:18:17.373-07:00

The bug with the inverse macro can only happen on a broken compiler, or maybe a very old one. The compiler has to remove comments and replace them with spaces before it executes preprocessor directives. So when it's doing macro substitution, comments no longer exist.

Also regarding overflow, if you use unsigned ints ...

2010-05-06T22:42:05.083-07:00

Also regarding overflow, if you use unsigned ints it is not undefined.

Your overflow examples are not valid code in the s...

2010-05-06T22:16:14.129-07:00

Your overflow examples are not valid code in the specification sense. Integer overflow is undefined behaviour . For example a compiler could rightfully optimize the if away, because (a+b < a) is always false for positive ints. Unfortunately many programs rely on this behaviour. Thus, a compiler writer not only has to know the C standard, but also the expectations.

Correction: Right shifting signed integers is not ...

2010-05-06T17:43:56.449-07:00

Correction: Right shifting signed integers is not undefined behavior. If the number is negative, it's implementation-defined behavior, otherwise it's defined. Left shifting signed integers is undefined behavior if an overflow occurs or if the number is negative.

Shifting signed integers is not undefined behavior...

2010-05-06T17:18:07.331-07:00

Shifting signed integers is not undefined behavior. It's implementation-defined behavior.

Imagine my surprise when reading through reddit.co...

2010-05-06T12:49:59.479-07:00

Imagine my surprise when reading through reddit.com and finding your blog ^^
- Isaak

That expression with the bunch of unary negative s...

2010-05-06T12:42:51.644-07:00

That expression with the bunch of unary negative sign operators is pretty trippy. So should we ask this one on C programmer interviews? Ha.