Pointer to pointer conversion

[WaterWalk]

Hello. When I practice pointers, I write code like the following:
int *pn1;
void **pv = (void **)&pn1;
*pv = malloc(sizeof(int));
*pn1 = 1;

It seems to work. But when I consult n1124(the draft c99 standard with
tc2), in section 6.3.2.3/7, it says:
"A pointer to an object or incomplete type may be converted to a
pointer to a different
object or incomplete type. If the resulting pointer is not correctly
aligned for the
pointed-to type, the behavior is undefined."

It seems this statement fits the above code. Since no document says
whether (void **) is properly aligned for (int **), is the above code
potentially dangerous?

[Pietro Cerutti]

WaterWalk wrote:

Hello. When I practice pointers, I write code like the following:
int *pn1;
void **pv = (void **)&pn1;
*pv = malloc(sizeof(int));
*pn1 = 1;

It seems to work. But when I consult n1124(the draft c99 standard with
tc2), in section 6.3.2.3/7, it says:
"A pointer to an object or incomplete type may be converted to a
pointer to a different
object or incomplete type. If the resulting pointer is not correctly
aligned for the
pointed-to type, the behavior is undefined."

Yes, but at 6.3.2.2/1, it says:

6.3.2.3 Pointers
1 A pointer to void may be converted to or from a pointer to any
incomplete or object type. A pointer to any incomplete or object
type may be converted to a pointer to void and back again; the
result shall compare equal to the original pointer.

the cast (void **) on &pn1 is not even necessary.

Moreover, I don't see the point of using pv to allocate room for pn1.

Why not just

pn1 = malloc(sizeof(int));

?

>
It seems this statement fits the above code. Since no document says
whether (void **) is properly aligned for (int **), is the above code
potentially dangerous?

--
Pietro Cerutti

[Iman S. H. Suyoto]

Pietro Cerutti wrote:

WaterWalk wrote:

>Hello. When I practice pointers, I write code like the following:
int *pn1;
void **pv = (void **)&pn1;
*pv = malloc(sizeof(int));
*pn1 = 1;

It seems to work. But when I consult n1124(the draft c99 standard with
tc2), in section 6.3.2.3/7, it says:
"A pointer to an object or incomplete type may be converted to a
pointer to a different
object or incomplete type. If the resulting pointer is not correctly
aligned for the
pointed-to type, the behavior is undefined."

Yes, but at 6.3.2.2/1, it says:

6.3.2.3 Pointers
1 A pointer to void may be converted to or from a pointer to any
incomplete or object type. A pointer to any incomplete or object
type may be converted to a pointer to void and back again; the
result shall compare equal to the original pointer.

the cast (void **) on &pn1 is not even necessary.

Moreover, I don't see the point of using pv to allocate room for pn1.

Why not just

pn1 = malloc(sizeof(int));

Even better:

pn1 = malloc(sizeof *pn1);

[Richard Heathfield]

Pietro Cerutti <gahr_SPAM_gahr_ME_chsaid:

WaterWalk wrote:

>Hello. When I practice pointers, I write code like the following:
int *pn1;
void **pv = (void **)&pn1;
*pv = malloc(sizeof(int));
*pn1 = 1;

It seems to work. But when I consult n1124(the draft c99 standard with
tc2), in section 6.3.2.3/7, it says:
"A pointer to an object or incomplete type may be converted to a
pointer to a different
object or incomplete type. If the resulting pointer is not correctly
aligned for the
pointed-to type, the behavior is undefined."

Yes, but at 6.3.2.2/1, it says:

6.3.2.3 Pointers
1 A pointer to void may be converted to or from a pointer to any
incomplete or object type. A pointer to any incomplete or object
type may be converted to a pointer to void and back again; the
result shall compare equal to the original pointer.

the cast (void **) on &pn1 is not even necessary.

void ** != void *

--
Richard Heathfield <http://www.cpax.org.uk>
Email: -http://www. +rjh@
Google users: <http://www.cpax.org.uk/prg/writings/googly.php>
"Usenet is a strange place" - dmr 29 July 1999

[Richard Heathfield]

WaterWalk said:

Hello. When I practice pointers, I write code like the following:
int *pn1;
void **pv = (void **)&pn1;

Unwise.

*pv = malloc(sizeof(int));

Unwiser.

*pn1 = 1;

It seems to work. But when I consult n1124(the draft c99 standard with
tc2), in section 6.3.2.3/7, it says:
"A pointer to an object or incomplete type may be converted to a
pointer to a different
object or incomplete type. If the resulting pointer is not correctly
aligned for the
pointed-to type, the behavior is undefined."

It seems this statement fits the above code. Since no document says
whether (void **) is properly aligned for (int **), is the above code
potentially dangerous?

Yes, and for precisely the reason you state. The guarantee that the C
Standard gives for void * does not extend to void **.

--
Richard Heathfield <http://www.cpax.org.uk>
Email: -http://www. +rjh@
Google users: <http://www.cpax.org.uk/prg/writings/googly.php>
"Usenet is a strange place" - dmr 29 July 1999

[Eric Sosman]

Pietro Cerutti wrote:

WaterWalk wrote:

>Hello. When I practice pointers, I write code like the following:
int *pn1;
void **pv = (void **)&pn1;
*pv = malloc(sizeof(int));
*pn1 = 1;

It seems to work. But when I consult n1124(the draft c99 standard with
tc2), in section 6.3.2.3/7, it says:
"A pointer to an object or incomplete type may be converted to a
pointer to a different
object or incomplete type. If the resulting pointer is not correctly
aligned for the
pointed-to type, the behavior is undefined."

Yes, but at 6.3.2.2/1, it says:

6.3.2.3 Pointers
1 A pointer to void may be converted to or from a pointer to any
incomplete or object type. A pointer to any incomplete or object
type may be converted to a pointer to void and back again; the
result shall compare equal to the original pointer.

Which variable in the sample code is a pointer to void?
(Hint: None of them is a pointer to void, so the paragraph
you quote does not apply.)

the cast (void **) on &pn1 is not even necessary.

If the cast is omitted, the compiler is required to emit
a diagnostic message. There is no implicit conversion from
`int**' (the type of `&pn1') to `void**'.

With the cast in place, no diagnostic is required but the
behavior is undefined. See Question 4.9 in the comp.lang.c
Frequently Asked Questions (FAQ) list, <http://www.c-faq.com/>.

>It seems this statement fits the above code. Since no document says
whether (void **) is properly aligned for (int **), is the above code
potentially dangerous?

Yes, and not only because of alignment issues. `void*'
and `int*' can have different representations and even different
sizes. On machines where this is true, `void*' is usually wider
than `int*', so the assignment `*pv = malloc(...)' could step
on memory adjacent to but not part of `pn1'.

The fact that `void*' can be used as a "generic pointer"
leads some to think that `void**' is a "generic pointer-to-
pointer," but there is no such animal in C.

--
Eric Sosman
es*****@ieee-dot-org.invalid

[Pietro Cerutti]

Eric Sosman wrote:

Pietro Cerutti wrote:

>WaterWalk wrote:

>>Hello. When I practice pointers, I write code like the following:
int *pn1;
void **pv = (void **)&pn1;
*pv = malloc(sizeof(int));
*pn1 = 1;

It seems to work. But when I consult n1124(the draft c99 standard with
tc2), in section 6.3.2.3/7, it says:
"A pointer to an object or incomplete type may be converted to a
pointer to a different
object or incomplete type. If the resulting pointer is not correctly
aligned for the
pointed-to type, the behavior is undefined."

Yes, but at 6.3.2.2/1, it says:

6.3.2.3 Pointers
1 A pointer to void may be converted to or from a pointer to any
incomplete or object type. A pointer to any incomplete or object
type may be converted to a pointer to void and back again; the
result shall compare equal to the original pointer.

Which variable in the sample code is a pointer to void?
(Hint: None of them is a pointer to void, so the paragraph
you quote does not apply.)

>the cast (void **) on &pn1 is not even necessary.

If the cast is omitted, the compiler is required to emit
a diagnostic message. There is no implicit conversion from
`int**' (the type of `&pn1') to `void**'.

With the cast in place, no diagnostic is required but the
behavior is undefined. See Question 4.9 in the comp.lang.c
Frequently Asked Questions (FAQ) list, <http://www.c-faq.com/>.

>>It seems this statement fits the above code. Since no document says
whether (void **) is properly aligned for (int **), is the above code
potentially dangerous?

Yes, and not only because of alignment issues. `void*'
and `int*' can have different representations and even different
sizes. On machines where this is true, `void*' is usually wider
than `int*', so the assignment `*pv = malloc(...)' could step
on memory adjacent to but not part of `pn1'.

The fact that `void*' can be used as a "generic pointer"
leads some to think that `void**' is a "generic pointer-to-
pointer," but there is no such animal in C.

Me being one of those :-(

Thanks for clarifying this point, sorry WaterWalk for the wrong advice.

--
Pietro Cerutti

[Keith Thompson]

Eric Sosman <es*****@ieee-dot-org.invalidwrites:
[...]

The fact that `void*' can be used as a "generic pointer"
leads some to think that `void**' is a "generic pointer-to-
pointer," but there is no such animal in C.

There is, sort of. You can use void* as a "generic
pointer-to-pointer" (but if you inadvertently assign a
pointer-to-something-else to it, the compiler won't catch your error).

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

[Eric Sosman]

Keith Thompson wrote:

Eric Sosman <es*****@ieee-dot-org.invalidwrites:
[...]

> The fact that `void*' can be used as a "generic pointer"
leads some to think that `void**' is a "generic pointer-to-
pointer," but there is no such animal in C.

There is, sort of. You can use void* as a "generic
pointer-to-pointer" (but if you inadvertently assign a
pointer-to-something-else to it, the compiler won't catch your error).

Since void* can point to any data, it can point to any
pointer, yes. But that's not the sense I was trying to
convey with the phrase "generic pointer-to-pointer," an
admittedly unofficial phrase but one that's also used by
the FAQ.

Here's what the FAQ and I mean by saying that C lacks
a "generic pointer-to-pointer:" We mean that there is no
type that can point at arbitrary pointer objects and can
manipulate those pointed-to objects as pointers. This is
the bane of "generic" linked-list packages, hash-table
packages, and so on, the usual unsatisfactory dodge being
to deal in `void*' pointers and document VERY LOUDLY that
they must actually be pointers to struct types.

--
Er*********@sun.com

[WaterWalk]

On May 22, 9:19 pm, WaterWalk <[e-mail]:

Hello. When I practice pointers, I write code like the following:
int *pn1;
void **pv = (void **)&pn1;
*pv = malloc(sizeof(int));
*pn1 = 1;

It seems to work. But when I consult n1124(the draft c99 standard with
tc2), in section 6.3.2.3/7, it says:
"A pointer to an object or incomplete type may be converted to a
pointer to a different
object or incomplete type. If the resulting pointer is not correctly
aligned for the
pointed-to type, the behavior is undefined."

It seems this statement fits the above code. Since no document says
whether (void **) is properly aligned for (int **), is the above code
potentially dangerous?

Thank you all. Now I know better this problem.