Q: reinterpret_cas t with undefined behavior?

[Jakob Bieling]

Hi,

I am trying to determine the endianness of the system as follows:

int i = 1;
bool is_little = *reinterpret_ca st <char*> (&i) != 0;

But now I was asking myself, if this use of reinterpret_cas t is
valid, according to the Standard.

thanks!
--
jb

(reply address in rot13, unscramble first)

[ben]

signed char or unsigned char?

ben

Hi,

I am trying to determine the endianness of the system as follows:

int i = 1;
bool is_little = *reinterpret_ca st <char*> (&i) != 0;

But now I was asking myself, if this use of reinterpret_cas t is
valid, according to the Standard.

thanks!
--
jb

(reply address in rot13, unscramble first)

[Jakob Bieling]

"ben" <be******@hotma il.com> wrote in message
news:42******** **************@ news.optusnet.c om.au

int i = 1;
bool is_little = *reinterpret_ca st <char*> (&i) != 0;

signed char or unsigned char?

On my system signed, but why does this matter? I am testing against
0 ..
--
jb

(reply address in rot13, unscramble first)

[Peter Koch Larsen]

"Jakob Bieling" <ar************ ****@rot13.com> skrev i en meddelelse
news:d4******** *****@news.t-online.com...

Hi,

I am trying to determine the endianness of the system as follows:

int i = 1;
bool is_little = *reinterpret_ca st <char*> (&i) != 0;

But now I was asking myself, if this use of reinterpret_cas t is valid,
according to the Standard.

thanks!
--
jb

(reply address in rot13, unscramble first)

This is perfectly valid - just go ahead. The signedness of char is
irrelevant in this respect.

/Peter

[Andrew Koenig]

"Jakob Bieling" <ar************ ****@rot13.com> wrote in message
news:d4******** *****@news.t-online.com...

int i = 1;
bool is_little = *reinterpret_ca st <char*> (&i) != 0;

But now I was asking myself, if this use of reinterpret_cas t is valid,
according to the Standard.

It is not. There is no requirement that int* and char* be represented in
compatible ways.

In fact, I can't even think of any requirement that the bits in an int be
stored in any particular order. If an implementation decided to store all
the even-numbered bits together, and then all the odd-numbered bits, I don't
think there would be anything wrong with that.

[Jakob Bieling]

"Andrew Koenig" <ar*@acm.org> wrote in message
news:IH******** ************@bg tnsc04-news.ops.worldn et.att.net

"Jakob Bieling" <ar************ ****@rot13.com> wrote in message
news:d4******** *****@news.t-online.com...

int i = 1;
bool is_little = *reinterpret_ca st <char*> (&i) != 0;

But now I was asking myself, if this use of reinterpret_cas t is
valid, according to the Standard.

It is not. There is no requirement that int* and char* be
represented in compatible ways.

In fact, I can't even think of any requirement that the bits in an
int be stored in any particular order. If an implementation decided
to store all the even-numbered bits together, and then all the
odd-numbered bits, I don't think there would be anything wrong with
that.

Guess I have to be more exact. Assuming the implementation uses
either the big- or the little-endian byte order and the binary
numeration system (as it 'shall' be used, according to 3.9.1/7).
Sticking to those restrictions, I assume the above code has still
unspecified behaviour, as your first point still stands, right? So I
came up with this:

char tmp [sizeof (int)];
int* i = new (tmp) int (1);
bool is_little = tmp [0] != 0;

Can I be sure of reading the memory used by the int, by accessing
'tmp' (still assuming that we have an implementation that conforms to
the restrictions I made above)?

Also, I was wondering, if I would have to call the d'tor there,
since it is just an int?

thanks!
--
jb

(reply address in rot13, unscramble first)

[Peter Koch Larsen]

"Andrew Koenig" <ar*@acm.org> skrev i en meddelelse
news:IH******** ************@bg tnsc04-news.ops.worldn et.att.net...

"Jakob Bieling" <ar************ ****@rot13.com> wrote in message
news:d4******** *****@news.t-online.com...

int i = 1;
bool is_little = *reinterpret_ca st <char*> (&i) != 0;

But now I was asking myself, if this use of reinterpret_cas t is valid,
according to the Standard.

It is not. There is no requirement that int* and char* be represented in
compatible ways.

In fact, I can't even think of any requirement that the bits in an int be
stored in any particular order. If an implementation decided to store all
the even-numbered bits together, and then all the odd-numbered bits, I
don't think there would be anything wrong with that.

I read the question as "is this reinterpret_cas t" legal and well-defined in
std C++. In that case the answer is a clear YES. If the question is in the
above code can determine all types of endianness, those in existence now as
well as any conceivable ones, then of course the answer is NO.

/Peter

[Ioannis Vranos]

Jakob Bieling wrote:

Hi,

I am trying to determine the endianness of the system as follows:

int i = 1;
bool is_little = *reinterpret_ca st <char*> (&i) != 0;

But now I was asking myself, if this use of reinterpret_cas t is
valid, according to the Standard.

I think this does the task:
#include <cstring>
#include <limits>
#include <vector>
bool IsLittleEndian( )
{
using namespace std;

unsigned int num= 0;

unsigned char buffer[sizeof(num)];

memcpy(buffer, &num, sizeof(num));

// Stores indices to modified bytes of num
unsigned indices[2];

const unsigned char *p= reinterpret_cas t<unsigned char *>(&num);

num= 1;

for(unsigned i=0; i<sizeof(num); ++i)
{
if(p[i]!= buffer[i])
{
indices[0]= i;
break;
}
}

num+= numeric_limits< unsigned char>::max();

for(unsigned i=0; i<sizeof(num); ++i)
{
if(p[i]!= buffer[i])
{
indices[1]= i;
break;
}
}

if(indices[0]< indices[1])
return true;

else
return false;
}

--
Ioannis Vranos

http://www23.brinkster.com/noicys

[Kanenas]

On Sat, 30 Apr 2005 13:26:01 GMT, "Andrew Koenig" <ar*@acm.org> wrote:

"Jakob Bieling" <ar************ ****@rot13.com> wrote in message
news:d4******* ******@news.t-online.com...

int i = 1;
bool is_little = *reinterpret_ca st <char*> (&i) != 0;

But now I was asking myself, if this use of reinterpret_cas t is valid,
according to the Standard.
It is not. There is no requirement that int* and char* be represented in
compatible ways.

Is "convertabl e so that one can always address the same memory
location as the other" a fair definition of what you mean by
"compatible "?
In fact, I can't even think of any requirement that the bits in an int be
stored in any particular order. If an implementation decided to store all
the even-numbered bits together, and then all the odd-numbered bits, I don't
think there would be anything wrong with that.

Such as an Intercal machine? That's a scary thought.

Kanenas

[Kanenas]

On Sat, 30 Apr 2005 13:26:01 GMT, "Andrew Koenig" <ar*@acm.org> wrote:

"Jakob Bieling" <ar************ ****@rot13.com> wrote in message
news:d4******* ******@news.t-online.com...

int i = 1;
bool is_little = *reinterpret_ca st <char*> (&i) != 0;

But now I was asking myself, if this use of reinterpret_cas t is valid,
according to the Standard.
It is not. There is no requirement that int* and char* be represented in
compatible ways.

Is "convertabl e so that a char* can always be made to point to the
same memory location as an int*" a fair definition of what you mean by
"compatible "?
In fact, I can't even think of any requirement that the bits in an int be
stored in any particular order. If an implementation decided to store all
the even-numbered bits together, and then all the odd-numbered bits, I don't
think there would be anything wrong with that.

Such as an Intercal machine? That's a scary thought.

Kanenas