2

When declaring or using in an artithmetic expression an integer constant expression in C of a type that’s defined in stdint.h, for instance uint64_t, one could cast the integer to the desired type (uint64_t)x, or use a Macro for Integer Constant Expressions such as UINT64_C(x) (where x is an integer constant expression).

I’m more enclined to use the macro, however I’m wondering in what cases the two approaches are equivalent, differ, and what could go wrong. More precisely: is there a case where using one would lead to a bug, but not with the other?

Thanks!

Antonin Décimo
  • 499
  • 3
  • 17

3 Answers3

3

More precisely: is there a case where using one would lead to a bug, but not with the other?

Yes, there are such cases, though they are rather contrived. Unary operators such as cast operators have high precedence, but all the postfix operators have higher. Of those, the indexing operator, [], can be applied to an integer constant when the expression inside is a pointer to a complete type. Thus, given this declaration in scope:

int a[4] = { 1, 2, 3, 4 };

... the expression (uint64_t) 1[a] evaluates to a uint64_t with value 2, whereas the expression UINT64_C(1)[a] evaluates to an int with value 2. The type difference can cause different behavior to manifest. That can arise from different implicit conversion behavior, which is generally a subtle effect, or if these are used as control expressions for a generic selection then the overall expression can evaluate to wildly different things depending on which variation you use.

However, I think there is no practical difference if you put the cast expression in parentheses: ((uint64_t) 1).

John Bollinger
  • 160,171
  • 8
  • 81
  • 157
2

An esoteric but possible case: If the system has no 64-bit type (e.g. 32-bit int, 128-bit long), then (uint64_t)1 will fail to compile, whereas UINT64_C(1) will give something of the smallest unsigned integer type larger than 64 bits.

The macro forms are likely to expand to suffixes rather than casts. But I can't think of any other situation where a conforming program would behave differently (other than the syntax precedence issue of course).

If the program is non-conforming then there are various possibilities, e.g. UINT64_C(-1) is undefined behaviour no diagnostic required, as is UINT8_C(256). The macro argument must be an unsuffixed integer constant that is in range for the target type.

M.M
  • 138,810
  • 21
  • 208
  • 365
  • Can you prove that `UINT64_C(-1)` is undefined behaviour? That’s not what http://brnz.org/hbr/?p=1433 and https://stackoverflow.com/a/31889511/3566655 seem to say. – Antonin Décimo Jun 04 '20 at 14:43
  • 1
    @AntoninDécimo yes, see C11 7.20.4/2 "The argument in any instance of these macros shall be an unsuffixed integer constant (as defined in 6.4.4.1) with a value that does not exceed the limits for the corresponding type". `-1` is not a constant, it's the unary minus operator applied to a constant – M.M Jun 04 '20 at 20:35
-1

Keep it simple and make everything clear and obvious to the reader. I.e. avoid the preprocessor as much as possible, and only introduce a cast where absolutely necessary.

Greg A. Woods
  • 2,663
  • 29
  • 26