On Fri, 5 Dec 2008, Garrett Cooper wrote:
On Fri, Dec 5, 2008 at 1:11 AM, Christoph Mallon
<[EMAIL PROTECTED]> wrote:
Garrett Cooper schrieb:
(I feel like I'm getting off on a bikeshed topic, but...)
1. What dialect of C was it defined in? Is it still used in the
standard dialect (honestly, this is the first time I've ever seen it
before, but then again I am a younger generation user)?
Dialect? The ! operator is plain vanilla standard C. It takes a scalar
operand and returns 1, if it compares equal to 0, otherwise it returns 0.
!!, i.e. two consecutive ! operators, is one of the oldest tricks in the
book, right next to (a > b) - (a < b) for comparison functions and countless
other idioms.
3. What's the real loss of going to `? :', beyond maybe 3 extra
keystrokes if it's easier for folks who may not be as experienced to
read?
I'd like my bikeshed grass green, please.
Christoph
If you really want to split hairs, ! only negates the logic value,
whereas ~ actually negates the bits. So technically, you're not
flipping 0 to make 1 and vice versa, but instead flipping 0 to make
non-zero, etc. There is a clear distinction in hardware.
The point was that !! isn't obvious at first glancing the C code. It's
important for code to be readable as well as functional (that's why we
have style(9)). Getting down to it I'd like to see what the compiler
optimizes each as, because I can see dumb compilers saying `!!'
translates to `not, bne => set, else set, continue', whereas `? :'
could be translated to `bne, set, else set, continue'; I'm sure gcc
has moved passed these really minute details.
Out of curiosity, I tried some various compilers, including gcc on i386,
amd64, and sparc; Intel's C compiler on i386; tcc (tiny, non-optimizing C
compiler) on i386; and Sun's compiler (old version) on sparc.
I compiled the following file:
int bangbang(int x) { return !!x; }
int ternary(int x) { return x ? 1 : 0; }
Intel's compiler generated different code for these two functions when
optimization was turned off. bangbang used a conditional set instruction,
while ternary used conditional jumps. With optimization on the two were
identical.
All other compilers generated identical code for the two functions whether
optimization was on or off. (Of course, the generated code varied between
compilers; tcc's in particular was decidedly non-optimized.)
I really don't think something as simple as this is worth worrying about
in terms of code efficiency. Even if they weren't identical, the
difference is at most a couple of instructions and a pipeline flush, and
if that's a serious problem you need to be using assembly anyway.
Besides, it's not a piece of code that comes up all that often.
The only basis for arguing about it is style, and I think we've
established that it's purely a matter of taste. In particular, there
isn't a clear favorite for which is easier to read. IMHO, style(9) should
remain agnostic and let the programmer decide.
However, if people really feel that consistency is necessary here, I
propose the following: if the cents digit of the closing price of the Dow
Jones Industrial Average on this coming Monday, December 8, 2008, is even,
then style(9) shall be edited to indicate that `!!x' is preferred. If
odd, then style(9) shall prefer `x ? 1 : 0'.
:-)
--
Nate Eldredge
[EMAIL PROTECTED]
_______________________________________________
freebsd-hackers@freebsd.org mailing list
http://lists.freebsd.org/mailman/listinfo/freebsd-hackers
To unsubscribe, send any mail to "[EMAIL PROTECTED]"
