(void) pointer arithmetic

[viza]

Hi all,

if I have:

void *vptr= malloc( ENOUGH );

is this guaranteed to always be true:

( (sometype*)vptr ) + 1 == vptr + sizeof(sometype )

it fails of course if sometype is void, and gcc sometimes screams
about void pointer arithmetic.

Also, is sizeof(char) guaranteed to always be 1? How does this
interact with CHAR_BIT?

Also, are

sizeof(unsigned sometype) == sizeof(sometype )
sizeof(unsigned sometype) == sizeof(signed sometype)

always guaranteed to be true for types which can be modified by signed
and unsigned?

On a similar track, what about:

( (unsigned sometype*)vptr ) + 1 == ( (sometype*)vptr ) + 1
( (unsigned sometype*)vptr ) + 1 == ( (signed sometype*)vptr ) + 1

Thanks,
viza

[Chris Dollin]

viza wrote:

if I have:

void *vptr= malloc( ENOUGH );

is this guaranteed to always be true:

( (sometype*)vptr ) + 1 == vptr + sizeof(sometype )

It's not legal C, since you can't do arithmetic on void*
values in standard C.

it fails of course if sometype is void, and gcc sometimes screams
about void pointer arithmetic.

gcc defaults to allowing void* arithmetic, but can be disuaded
with suitable command-line options.

Also, is sizeof(char) guaranteed to always be 1?

Yes.

How does this interact with CHAR_BIT?

It doesn't. 1 is 1 and all alone and ever more shall be so.

--
"It would have to be enough." /Brokedown Palace/

Hewlett-Packard Limited registered no:
registered office: Cain Road, Bracknell, Berks RG12 1HN 690597 England

[vippstar]

On Jun 10, 5:17 pm, viza <tom.v...@gmail .comwrote:

Hi all,

if I have:

void *vptr= malloc( ENOUGH );

is this guaranteed to always be true:

( (sometype*)vptr ) + 1 == vptr + sizeof(sometype )

Don't you mean
((type*)ptr)+1 == ((char*)ptr)+si zeof(type)
In that case, yes, it is guaranteed.

>
it fails of course if sometype is void, and gcc sometimes screams
about void pointer arithmetic.

void pointer arithmetic is not allowed by ISO C90/C99. (and ANSI C89)
However, gcc allows it as an extension, (it will *error* in c89/c99
mode)

Also, is sizeof(char) guaranteed to always be 1? How does this
interact with CHAR_BIT?

It does not. sizeof(char) is guaranteed to be 1 and CHAR_BIT at least
8.

Also, are

sizeof(unsigned sometype) == sizeof(sometype )
sizeof(unsigned sometype) == sizeof(signed sometype)

always guaranteed to be true for types which can be modified by signed
and unsigned?

Types are not modified by signed and unsigned, but yes, it is
guaranteed.

>
On a similar track, what about:

( (unsigned sometype*)vptr ) + 1 == ( (sometype*)vptr ) + 1
( (unsigned sometype*)vptr ) + 1 == ( (signed sometype*)vptr ) + 1

Yes

[Ben Bacarisse]

vi******@gmail. com writes:

On Jun 10, 5:17 pm, viza <tom.v...@gmail .comwrote:

>if I have:

void *vptr= malloc( ENOUGH );

is this guaranteed to always be true:

( (sometype*)vptr ) + 1 == vptr + sizeof(sometype )

Don't you mean
((type*)ptr)+1 == ((char*)ptr)+si zeof(type)
In that case, yes, it is guaranteed.

If *you* mean:

(void *)((type *)ptr + 1) == (void *)((char *)ptr + sizeof(type))

then yes. In your example the two pointer types can't be compared
(unless type is a character type).

--
Ben.

[rahul]

On Jun 10, 7:33 pm, vipps...@gmail. com wrote:

On Jun 10, 5:17 pm, viza <tom.v...@gmail .comwrote:Hi all,

if I have:

void *vptr= malloc( ENOUGH );

is this guaranteed to always be true:

( (sometype*)vptr ) + 1 == vptr + sizeof(sometype )

Don't you mean
((type*)ptr)+1 == ((char*)ptr)+si zeof(type)
In that case, yes, it is guaranteed.

it fails of course if sometype is void, and gcc sometimes screams
about void pointer arithmetic.

void pointer arithmetic is not allowed by ISO C90/C99. (and ANSI C89)
However, gcc allows it as an extension, (it will *error* in c89/c99
mode)Also, is sizeof(char) guaranteed to always be 1? How does this

interact with CHAR_BIT?

It does not. sizeof(char) is guaranteed to be 1 and CHAR_BIT at least
8.Also, are

sizeof(unsigned sometype) == sizeof(sometype )
sizeof(unsigned sometype) == sizeof(signed sometype)

always guaranteed to be true for types which can be modified by signed
and unsigned?

Types are not modified by signed and unsigned, but yes, it is
guaranteed.

On a similar track, what about:

( (unsigned sometype*)vptr ) + 1 == ( (sometype*)vptr ) + 1
( (unsigned sometype*)vptr ) + 1 == ( (signed sometype*)vptr ) + 1

Yes

Correct me if I am wrong:

sizeof(char) is 1 and CHAR_BITS is >= 8. What exactly sizeof returns?
AFAIK it returns number of bytes. So 1 byte in C is sizeof char but
not necesarily this byte has to be 8 bits. Its not that the sizeof
char is defined in terms of bytes but bytes are defined in terms of
sizeof char.

[Thad Smith]

Ben Bacarisse wrote:

vi******@gmail. com writes:

>On Jun 10, 5:17 pm, viza <tom.v...@gmail .comwrote:

>>if I have:

void *vptr= malloc( ENOUGH );

is this guaranteed to always be true:

( (sometype*)vptr ) + 1 == vptr + sizeof(sometype )

>Don't you mean
((type*)ptr) +1 == ((char*)ptr)+si zeof(type)
In that case, yes, it is guaranteed.

If *you* mean:

(void *)((type *)ptr + 1) == (void *)((char *)ptr + sizeof(type))

then yes. In your example the two pointer types can't be compared
(unless type is a character type).

Assuming that vptr is not a null pointer.

--
Thad