Shash - 1 year ago 76
C Question

what is the reason for explicitly declaring L or UL for long values

From an Example

``````unsigned long x = 12345678UL
``````

We have always learnt that the compiler needs to see only "long" in the above example to set 4 bytes (in 32 bit) of memory. The question is why is should we use L/UL in long constants even after declaring it to be a long.

When a suffix `L` or `UL` is not used, the compiler uses the first type that can contain the constant from a list (see details in C99 standard, clause 6.4.4:5. For a decimal constant, the list is `int`, `long int`, `long long int`).

As a consequence, most of the times, it is not necessary to use the suffix. It does not change the meaning of the program. It does not change the meaning of your example initialization of `x` for most architectures, although it would if you had chosen a number that could not be represented as a `long long`. See also codebauer's answer for an example where the `U` part of the suffix is necessary.

There are a couple of circumstances when the programmer may want to set the type of the constant explicitly. One example is when using a variadic function:

``````printf("%lld", 1LL); // correct
printf("%lld", 1);   // undefined behavior
``````

A common reason to use a suffix is ensuring that the result of a computation doesn't overflow. Two examples are:

``````long x = 10000L * 4096L;
unsigned long long y = 1ULL << 36;
``````

In both examples, without suffixes, the constants would have type `int` and the computation would be made as `int`. In each example this incurs a risk of overflow. Using the suffixes means that the computation will be done in a larger type instead, which has sufficient range for the result.

As Lightness Races in Orbit puts it, the litteral's suffix comes before the assignment. In the two examples above, simply declaring `x` as `long` and `y` as `unsigned long long` is not enough to prevent the overflow in the computation of the expressions assigned to them.

Another example is the comparison `x < 12U` where variable `x` has type `int`. Without the `U` suffix, the compiler types the constant `12` as an `int`, and the comparison is therefore a comparison of signed ints.

``````int x = -3;
printf("%d\n", x < 12); // prints 1 because it's true that -3 < 12
``````

With the `U` suffix, the comparison becomes a comparison of unsigned ints. “Usual arithmetic conversions” mean that -3 is converted to a large unsigned int:

``````printf("%d\n", x < 12U); // prints 0 because (unsigned int)-3 is large
``````

In fact, the type of a constant may even change the result of an arithmetic computation, again because of the way “usual arithmetic conversions” work.

Note that, for decimal constants, the list of types suggested by C99 does not contain `unsigned long long`. In C90, the list ended with the largest standardized unsigned integer type at the time (which was `unsigned long`). A consequence was that the meaning of some programs was changed by adding the standard type `long long` to C99: the same constant that was typed as `unsigned long` in C90 could now be typed as a signed `long long` instead. I believe this is the reason why in C99, it was decided not to have `unsigned long long` in the list of types for decimal constants. See this and this blog posts for an example.

Recommended from our users: Dynamic Network Monitoring from WhatsUp Gold from IPSwitch. Free Download