integer to pinter conversion

[junky_fellow]

Consider a function:

void *test_func(void )
{
return ((void *)-1);
}

While returning, the integer -1 is converted to void *.
Is this portable ?

[Irrwahn Grausewitz]

ju**********@ya hoo.co.in wrote:

Consider a function:

void *test_func(void )
{
return ((void *)-1);
}

While returning, the integer -1 is converted to void *.
Is this portable ?

No. While an integer may be converted to a pointer, the result
of this conversion is implementation-defined, with the obvious
exception of an integer constant expression with the value 0.

FWIW, you don't even need the cast in the code above.

Best regards.
--
Irrwahn Grausewitz (ir*******@free net.de)
welcome to clc : http://www.ungerhu.com/jxh/clc.welcome.txt
clc faq-list : http://www.faqs.org/faqs/C-faq/faq/
clc frequent answers: http://benpfaff.org/writings/clc

[pete]

ju**********@ya hoo.co.in wrote:

Consider a function:

void *test_func(void )
{
return ((void *)-1);
}

While returning, the integer -1 is converted to void *.
Is this portable ?

No.

--
pete

[junky_fellow]

Irrwahn Grausewitz wrote:

ju**********@ya hoo.co.in wrote:

Consider a function:

void *test_func(void )
{
return ((void *)-1);
}

While returning, the integer -1 is converted to void *.
Is this portable ?

No. While an integer may be converted to a pointer, the result
of this conversion is implementation-defined, with the obvious
exception of an integer constant expression with the value 0.

FWIW, you don't even need the cast in the code above.

Is the conversion of integer to pointer and back again (pointer to
integer) will give the original integer ?

[Irrwahn Grausewitz]

ju**********@ya hoo.co.in wrote:

Irrwahn Grausewitz wrote:

ju**********@ya hoo.co.in wrote:

>Consider a function:
>
>void *test_func(void )
>{
> return ((void *)-1);
>}
>
>While returning, the integer -1 is converted to void *.
>Is this portable ?

No. While an integer may be converted to a pointer, the result
of this conversion is implementation-defined, with the obvious
exception of an integer constant expression with the value 0.

FWIW, you don't even need the cast in the code above.

Is the conversion of integer to pointer and back again (pointer to
integer) will give the original integer ?

I can't find any such guarantee in the standard, so I'd say: no.

IMO, if you feel the need to convert pointers to ints and vice versa,
your program logic is broken.

Best regards
--
Irrwahn Grausewitz (ir*******@free net.de)
welcome to clc : http://www.ungerhu.com/jxh/clc.welcome.txt
clc faq-list : http://www.faqs.org/faqs/C-faq/faq/
clc frequent answers: http://benpfaff.org/writings/clc

[Lawrence Kirby]

On Wed, 14 Sep 2005 01:19:36 -0700, junky_fellow wrote:

Irrwahn Grausewitz wrote:

ju**********@ya hoo.co.in wrote:

>Consider a function:
>
>void *test_func(void )
>{
> return ((void *)-1);
>}
>
>While returning, the integer -1 is converted to void *.
>Is this portable ?
No. While an integer may be converted to a pointer, the result
of this conversion is implementation-defined, with the obvious
exception of an integer constant expression with the value 0.

FWIW, you don't even need the cast in the code above.

Yes, you do, the only integer calues that can be converted to pointer
types without a cast are null pointer constants, and -1 isn't one of those.
Is the conversion of integer to pointer and back again (pointer to
integer) will give the original integer ?

No, converting an integer to a pointer can result in a trap
representation. In which case just looking at the value will cause
undefined behaviour.

Lawrence

[Irrwahn Grausewitz]

Lawrence Kirby <lk****@netacti ve.co.uk> wrote:

Irrwahn Grausewitz wrote:

ju**********@ya hoo.co.in wrote:
>Consider a function:
>
>void *test_func(void )
>{
> return ((void *)-1);
>}
>
>While returning, the integer -1 is converted to void *.
>Is this portable ?

No. While an integer may be converted to a pointer, the result
of this conversion is implementation-defined, with the obvious
exception of an integer constant expression with the value 0.

FWIW, you don't even need the cast in the code above.

Yes, you do, the only integer calues that can be converted to pointer
types without a cast are null pointer constants, and -1 isn't one of those.

<snip>

Oops, you're right, I forgot about assignment constraints.

Best regards
--
Irrwahn Grausewitz (ir*******@free net.de)
welcome to clc : http://www.ungerhu.com/jxh/clc.welcome.txt
clc faq-list : http://www.faqs.org/faqs/C-faq/faq/
clc frequent answers: http://benpfaff.org/writings/clc

[Walter Roberson]

In article <11************ *********@g49g2 000cwa.googlegr oups.com>,
<ju**********@y ahoo.co.in> wrote:

Is the conversion of integer to pointer and back again (pointer to
integer) will give the original integer ?

KR2 promises that it will [provided the sizes are compatable], but
C89 does NOT have that guarantee.

In the simplest case: conversion of the integer constant 0 to
a pointer results in the "null pointer constant", which is NOT certain to
be all-zeroes internally. Converting the null pointer constant
to an integer is not defined as returning 0.

Furthermore, C89 allows for the possibility that a null pointer
constant, when converted to pointer type other than void *, might take
on a different value, not necessarily the same for each type. Converting
that back to void * is not certain to result in a bit pattern which
is the same as the canonical null pointer constant: it is only
certain that no matter what sequence of pointer conversions one
undertakes, that all null pointers will compare equal.

--
Entropy is the logarithm of probability -- Boltzmann

[SM Ryan]

ju**********@ya hoo.co.in wrote:
# Consider a function:
#
# void *test_func(void )
# {
# return ((void *)-1);
# }
#
# While returning, the integer -1 is converted to void *.
# Is this portable ?

The code is portable. What it means depends on the system.

--
SM Ryan http://www.rawbw.com/~wyrmwif/
I think that's kinda of personal; I don't think I should answer that.

[Irrwahn Grausewitz]

SM Ryan <wy*****@tang o-sierra-oscar-foxtrot-tango.fake.org> wrote:

ju**********@y ahoo.co.in wrote:
#
# void *test_func(void )
# {
# return ((void *)-1);
# }
#
# While returning, the integer -1 is converted to void *.
# Is this portable ?

The code is portable.
Nope, it's not portable. Well, unless you refer to portable as in
beer, not in programming: you can print it out and carry it around.
By that definition, all code is portable.
What it means depends on the system.

Three very popular meanings:
1. You shoot yourself in the foot.
2. You shoot yourself in the foot, but don't notice.
3. You shoot yourself in someone else's foot.

Best regards
--
Irrwahn Grausewitz (ir*******@free net.de)
welcome to clc : http://www.ungerhu.com/jxh/clc.welcome.txt
clc faq-list : http://www.faqs.org/faqs/C-faq/faq/
clc frequent answers: http://benpfaff.org/writings/clc