Is this printf okay?

[Jerry Newsome]

If sizeof(int) = sizeof(long), is this undefined behavior or is it okay?

#include <stdio.h>
int main(void)
{
int i = 5;
long l = 7;
printf("i = %ld\n", i);
printf("l = %d\n", l);
return 0;
}

--
Jerry

[James Kuyper]

Jerry Newsome wrote:

If sizeof(int) = sizeof(long), is this undefined behavior or is it okay?

#include <stdio.h>
int main(void)
{
int i = 5;
long l = 7;
printf("i = %ld\n", i);
printf("l = %d\n", l);
return 0;
}

Undefined behavior. Even if the two types have the same size, there
might be padding bits in either type, and they might not be the same
bits. There might be trap representations in one type, that are not trap
representations in the other type. One of them could be two's
complement, the other might use sign-and-magnitude. It's also possible
that one is bigendian and the other is little-endian.

Of course, in the real world none of those complications is very
likely, so your code will probably work as you expect on such
implementations, unless the compiler deliberately rejects it.. But why
do it the wrong way? Doing it the right way is just as easy and a lot
more portable.

[Citizen C]

On Tue, 08 Jan 2008 03:46:41 +0000, James Kuyper wrote:

Jerry Newsome wrote:

>If sizeof(int) = sizeof(long), is this undefined behavior or is it
okay?

#include <stdio.h>
int main(void)
{
int i = 5;
long l = 7;
printf("i = %ld\n", i);
printf("l = %d\n", l);
return 0;
}

Undefined behavior. Even if the two types have the same size, there
might be padding bits in either type, and they might not be the same
bits. There might be trap representations in one type, that are not trap
representations in the other type. One of them could be two's
complement, the other might use sign-and-magnitude. It's also possible
that one is bigendian and the other is little-endian.

Of course, in the real world none of those complications is very
likely, so your code will probably work as you expect on such
implementations, unless the compiler deliberately rejects it.. But why
do it the wrong way? Doing it the right way is just as easy and a lot
more portable.

Hi James,

Thanks for your response.

The motivation for my question was a result of me coming across real-
world C90 code that did stuff like this:

typedef long signed_32;

signed_32 s32 = 5;
printf("x = %ld\n", s32);

and then it was changed to the following because type long on the new
platform/compiler was 64 bits instead of 32 bits (and type int was 32
bits):

typedef int signed_32;

signed_32 s32 = 5;
printf("x = %ld\n", s32);/*whoops, conversion specifier not updated*/

Nevertheless, your response raises some interesting questions.

If sizeof(int) = sizeof(long), then, according to the C Standard:

Can type int have a trap representation whereas type long does not, or
vice versa?

Can type int be two's complement whereas type long is sign-and-magnitude,
or vice versa?

Can type int be Little Endian whereas type long is Big Endian, or vice
versa?

If any of the answers are yes, can you, or anyone else, give me an
example of a real-world compiler that answers yes to any of the above?

Thanks
--
Jerry

[Jerry Newsome]

On Tue, 08 Jan 2008 03:46:41 +0000, James Kuyper wrote:

Jerry Newsome wrote:

>If sizeof(int) = sizeof(long), is this undefined behavior or is it
okay?

#include <stdio.h>
int main(void)
{
int i = 5;
long l = 7;
printf("i = %ld\n", i);
printf("l = %d\n", l);
return 0;
}

Undefined behavior. Even if the two types have the same size, there
might be padding bits in either type, and they might not be the same
bits. There might be trap representations in one type, that are not trap
representations in the other type. One of them could be two's
complement, the other might use sign-and-magnitude. It's also possible
that one is bigendian and the other is little-endian.

Of course, in the real world none of those complications is very
likely, so your code will probably work as you expect on such
implementations, unless the compiler deliberately rejects it.. But why
do it the wrong way? Doing it the right way is just as easy and a lot
more portable.

Hi James,

Thanks for your response.

The motivation for my question was a result of me coming across real-
world C90 code that did stuff like this:

typedef long signed_32;

signed_32 s32 = 5;
printf("x = %ld\n", s32);

and then it was changed to the following because type long on the new
platform/compiler was 64 bits instead of 32 bits (and type int was 32
bits):

typedef int signed_32;

signed_32 s32 = 5;
printf("x = %ld\n", s32);/*whoops, conversion specifier not updated*/

Nevertheless, your response raises some interesting questions.

If sizeof(int) = sizeof(long), then, according to the C Standard:

Can type int have a trap representation whereas type long does not, or
vice versa?

Can type int be two's complement whereas type long is sign-and-magnitude,
or vice versa?

Can type int be Little Endian whereas type long is Big Endian, or vice
versa?

If any of the answers are yes, can you, or anyone else, give me an
example of a real-world compiler that answers yes to any of the above?

Thanks
--
Jerry Citizen C

[James Kuyper]

Citizen C wrote:
....

If sizeof(int) = sizeof(long), then, according to the C Standard:

Can type int have a trap representation whereas type long does not, or
vice versa?

Can type int be two's complement whereas type long is sign-and-magnitude,
or vice versa?

Can type int be Little Endian whereas type long is Big Endian, or vice
versa?

Yes, the standard says nothing to prohibit any of those possibilities.

If any of the answers are yes, can you, or anyone else, give me an
example of a real-world compiler that answers yes to any of the above?

Not me; I'm familiar with only a tiny fraction of the world's compilers,
and none of the ones I know have any of those characteristics. In fact,
few of them have sizeof(int)==sizeof(long), so the rest of the question
becomes moot.

[Keith Thompson]

James Kuyper <ja*********@verizon.netwrites:

Citizen C wrote:
...

>If sizeof(int) = sizeof(long), then, according to the C Standard:

Can type int have a trap representation whereas type long does not,
or vice versa?

Can type int be two's complement whereas type long is
sign-and-magnitude, or vice versa?

Can type int be Little Endian whereas type long is Big Endian, or
vice versa?

Yes, the standard says nothing to prohibit any of those possibilities.

>If any of the answers are yes, can you, or anyone else, give me an
example of a real-world compiler that answers yes to any of the
above?

Not me; I'm familiar with only a tiny fraction of the world's
compilers, and none of the ones I know have any of those
characteristics. In fact, few of them have sizeof(int)==sizeof(long),
so the rest of the question becomes moot.

On old Cray vector machines (T90 et al), sizeof(int) and sizeof(long)
are both (with CHAR_BIT=8). I *think* that int has padding bits, but
long doesn't.

--
Keith Thompson (The_Other_Keith) <ks***@mib.org>
Nokia
"We must do something. This is something. Therefore, we must do this."
-- Antony Jay and Jonathan Lynn, "Yes Minister"