pearls

 if (!foo) {
     return NULL;
 } else {
     return foo;
 }

 (<boolean expression>) ? true : false

 foo ? -foo : 0

Trackbacks

Aucun trackback.

Les trackbacks pour ce billet sont fermés.

Commentaires

1. Le Wednesday 29 November 2006 à 13:03, par Ben Hutchings

Got to avoid negative zero, you know! (There are systems with two zeroes - though they should be normalised to just one in most circumstances.)

2. Le Wednesday 29 November 2006 à 15:04, par MadCoder :: site

not true, that's an int, and there is no signed zeroes integers in C.

what is undefined in C is what happens when you have an overflow, e.g an int that is equal to MAX_INT that you increment (or to MIN_INT and that you decrement).

but the opposite is always defined for any valid integer value: when 0xffffffff is the trap value, it's not a valid integer value, end of problem, and when it's MIN_INT, then well, -MIN_INT == MIN_INT, which is surprising, but still defined :)

3. Le Wednesday 29 November 2006 à 20:31, par Anonymous

The first one technically serves a useful purpose: in C, the standard does not guarantee that NULL has a zero value. Nowadays, however, that assumption has become reasonable.

The second one helps if the "boolean" expression does not necessarily have the value 0 or 1, but rather 0 or non-zero.

The third, however, serves no useful purpose. :)

4. Le Wednesday 29 November 2006 à 20:42, par MadCoder :: site

untrue, in the C standard, §6.3.2.3 states that NULL == (void *)0. for any integer value of 0 (aka 0, 0L, 0LL, ...).

moreover for any type, (type *)NULL == (void *)NULL == (void *)0.


and for the second, instead of: return (foo) ? 1 : 0; if foo is not (like I especially mentionned it) a boolean expression, then you can do:

return !!(foo);

or, to be more "clean":

#define FORCE_BOOL(expr) (!!(expr))

return FORCE_BOOL(expr);

5. Le Thursday 30 November 2006 à 00:40, par Ben Hutchings

I was joking about negative zero.

As for null pointers, not only literal zeroes but *any* integer constant expression evaluating to 0 - such as 42/6-7 - can implicitly be converted to a null pointer of any pointer type. I think your anonymous commenter is remembering that casting an integer *variable* with value 0 might not result in a null pointer.

6. Le Tuesday 5 December 2006 à 20:29, par Ray Lee :: site

Signed zeroes are explicitly allowed by the C standard, always has been. This isn't ancient stuff either, the latest C99 draft I could find on the web (google c99 standard, it's the third link, pdf), has in section 6.2.6.2:

2. For signed integer types, the bits of the object representation shall be divided into three groups: value bits, padding bits, and the sign bit. There need not be any padding bits; there shall be exactly one sign bit. Each bit that is a value bit shall have the same value as
the same bit in the object representation of the corresponding unsigned type (if there are M value bits in the signed type and N in the unsigned type, then M ≤ N ). If the sign bit is zero, it shall not affect the resulting value. If the sign bit is one, the value shall be modified in one of the following ways:

— the corresponding value with sign bit 0 is negated (sign and magnitude);
— the sign bit has the value −(2 N ) (two’s complement);
— the sign bit has the value −(2 N − 1) (ones’ complement).

Which of these applies is implementation-defined, as is whether the value with sign bit 1 and all value bits zero (for the first two), or with sign bit and all value bits 1 (for ones’ complement), is a trap representation or a normal value. In the case of sign and magnitude and ones’ complement, if this representation is a normal value it is called a negative zero.

3. If the implementation supports negative zeros, they shall be generated only by:
— the &, |, ^, ~, <<, and >> operators with arguments that produce such a value;
— the +, -, *, /, and % operators where one argument is a negative zero and the result is zero;
— compound assignment operators based on the above cases.

It is unspecified whether these cases actually generate a negative zero or a normal zero, and whether a negative zero becomes a normal zero when stored in an object.

(End of quote.)

Ajouter un commentaire