casting between pointers

[scroopy]

hi,

why does the following produce an output of 64769 instead of 1

int main()
{
bool* pBool = new bool(false);

unsigned short* pUS = (unsigned short*)pBool;

cout << *pUS;

delete pBool;

return 0;
}

I expected the output to be 1 since the size of a bool and the size of
an unsigned int is 1

[Jakob Bieling]

scroopy <sc*****@nospam.com> wrote:

why does the following produce an output of 64769 instead of 1
Because you get undefined behaviour when casting one pointer type to
another and using it as that. You know .. the
demons-fly-out-of-your-nose issues ..
int main()
{
bool* pBool = new bool(false);

unsigned short* pUS = (unsigned short*)pBool;

cout << *pUS;

delete pBool;

return 0;
}

I expected the output to be 1 since the size of a bool and the size of
an unsigned int is 1

hth
--
jb

(reply address in rot13, unscramble first)

[Jim Langston]

"scroopy" <sc*****@nospam.com> wrote in message
news:vl********************************@4ax.com...

hi,

why does the following produce an output of 64769 instead of 1

int main()
{
bool* pBool = new bool(false);

unsigned short* pUS = (unsigned short*)pBool;

cout << *pUS;

delete pBool;

return 0;
}

I expected the output to be 1 since the size of a bool and the size of
an unsigned int is 1

On what system? The size of an unsigned char would be 1, unsigned short
would probably be 2?

[Carlos Martinez Garcia]

Hi scroopy:

scroopy wrote:

hi,

why does the following produce an output of 64769 instead of 1

int main()
{
bool* pBool = new bool(false);

unsigned short* pUS = (unsigned short*)pBool;

cout << *pUS;

delete pBool;

return 0;
}

I expected the output to be 1 since the size of a bool and the size of
an unsigned int is 1

C++ Standard says "sizeof(bool) is not required to be 1."
I think size of bool type depends on your compiler.

Are you sure that in your compiler sizeof(bool)==sizeof(unsigned short)

Why do you think the result must be 1?
Supossing that for your compiler, sizeof(bool)==sizeof(unsigned short),
the result will be 0.

[Bob Hairgrove]

On Wed, 29 Mar 2006 10:30:48 +0100, scroopy <sc*****@nospam.com>
wrote:

I expected the output to be 1 since the size of a bool and the size of
an unsigned int is 1

This is implementation-defined. On 16-bit Intel x86 platforms, for
example, sizeof(int) is 2; on 32-bit platforms it is usually 4, and on
64-bit platforms 8. Other platforms exist where this is different.

bool can also be implemented using a single bit, even if sizeof(bool)
implies something else. So even if a bool variable might occupy the
same storage as an int, the compiler might just ignore all but one of
the bits (which one, again, would be implementation-defined).

--
Bob Hairgrove
No**********@Home.com

[Raider]

It seems you are writing 1 byte and reading 2. Second byte is
undefined. Add the following line:

assert( sizeof(bool) == sizeof(unsigned short) );

before casting your pointers. And you will get an error message if
casting is not possible.

And IMHO "false" is not equals to 1. I suppose it fills all
sizeof(bool) bytes by "1" bits. It is 0xFF for sizeof(bool)==1 and so
on.

Raider

[Jakob Bieling]

Jakob Bieling <ar****************@rot13.com> wrote:

scroopy <sc*****@nospam.com> wrote:

why does the following produce an output of 64769 instead of 1

Because you get undefined behaviour when casting one pointer type

Wee correction: it is not undefined, but implementation defined. So
no demons now ;) But you would have to check your compiler manual or a
newsgroup dedicated for your compiler to find out why you get that
result.

On my system, I would get a similar result to yours. I have
sizeof(bool) == 1 and sizeof (unsigned short) == 2 .. by just observing
what is happening, I can see that the short pointer lets me read memory,
that does not belong to the bool anymore, ie. it contains junk. The
bool-part is 1 tho. Here at least.

regards
--
jb

(reply address in rot13, unscramble first)

[Daniel T.]

In article <vl********************************@4ax.com>,
scroopy <sc*****@nospam.com> wrote:

hi,

why does the following produce an output of 64769 instead of 1

int main()
{
bool* pBool = new bool(false);

unsigned short* pUS = (unsigned short*)pBool;

cout << *pUS;

delete pBool;

return 0;
}

I expected the output to be 1 since the size of a bool and the size of
an unsigned int is 1

On my system, sizeof short is 2, while sizeof bool is 4. What the sizeof
unsigned int has to do with the above program I have no idea...
--
Magic depends on tradition and belief. It does not welcome observation,
nor does it profit by experiment. On the other hand, science is based
on experience; it is open to correction by observation and experiment.

[Old Wolf]

Daniel T. wrote:

scroopy <sc*****@nospam.com> wrote:

why does the following produce an output of 64769 instead of 1

bool* pBool = new bool(false);
unsigned short* pUS = (unsigned short*)pBool;
cout << *pUS;

I expected the output to be 1 since the size of a bool and the size of
an unsigned int is 1

On my system, sizeof short is 2, while sizeof bool is 4. What the sizeof
unsigned int has to do with the above program I have no idea...

If sizeof(unsigned int) == 1, it would imply that sizeof(unsigned
short) is also 1, because short cannot be bigger than int.

To answer the original question, and assuming the quoted sizes are
correct: probably the bool only uses one bit of storage, so the other
bits could contain garbage values. The result of trying to read *pUS
will be:
- undefined, if sizeof(unsigned short) > sizeof(bool)
- undefined, if the content of the memory region in question does
not represent a valid unsigned short
- well-defined otherwise.

ISTR that unsigned types are not allowed to have trap representations,
so the second case might never happen.