A malloc question

[Why Tea]

What happens to the pointer below?

SomeStruct *p;
p = malloc(100*size of(SomeStruct)) ; /* without a cast */
return((void *)(p+1)); /* will the returned pointer point
to the 2nd struct? */

Seems to me there is no guarantee it will.

/Why Tea

[jacob navia]

Why Tea a écrit :

What happens to the pointer below?

SomeStruct *p;
p = malloc(100*size of(SomeStruct)) ; /* without a cast */
return((void *)(p+1)); /* will the returned pointer point
to the 2nd struct? */

Seems to me there is no guarantee it will.

/Why Tea

In my opinion it must point to p+1. Since p is a pointer
to SomeStruct, p+1 points to the second structure
in the table.

[Prasad J Pandit]

Why Tea wrote:

What happens to the pointer below?
SomeStruct *p;
p = malloc(100*size of(SomeStruct)) ; /* without a cast */
return((void *)(p+1)); /* will the returned pointer point
to the 2nd struct? */
Seems to me there is no guarantee it will.

Hello there,

The pointer arithmatic works according to the `type' of the pointer
`p'
that is `SomeStruct'.
So, the returned pointer should point to the 2'nd struct in the
dynamically
allocated array.

---
Regards
-PJP
http://www.cdacbangalore.in/~prasad

[Kohn Emil Dan]

On Thu, 28 Dec 2006, jacob navia wrote:

Why Tea a écrit :

>What happens to the pointer below?

SomeStruct *p;
p = malloc(100*size of(SomeStruct)) ; /* without a cast */
return((void *)(p+1)); /* will the returned pointer point
to the 2nd struct? */

Seems to me there is no guarantee it will.

/Why Tea

In my opinion it must point to p+1. Since p is a pointer
to SomeStruct, p+1 points to the second structure
in the table.

Assuming of course that a valid declaration of malloc() is in scope (e.g.
via #include <stdlib.h>), and the memory allocation succeeded. Otherwise,
the behavior is undefined.

Emil

[Scorpio]

Why Tea wrote:

What happens to the pointer below?

SomeStruct *p;
p = malloc(100*size of(SomeStruct)) ; /* without a cast */
return((void *)(p+1)); /* will the returned pointer point
to the 2nd struct? */

Seems to me there is no guarantee it will.

Yes, there is no guarantee. You did not check if your allocation is
successful or not before returning the pointer.

[Richard Heathfield]

Why Tea said:

What happens to the pointer below?

SomeStruct *p;
p = malloc(100*size of(SomeStruct)) ; /* without a cast */
return((void *)(p+1)); /* will the returned pointer point
to the 2nd struct? */

Seems to me there is no guarantee it will.

Provided you have a prototype in scope for malloc (i.e. you have included
<stdlib.h>), and provided malloc did not return NULL (which you do not
check), the returned pointer will indeed point to space properly aligned
for the SomeStruct type, at an offset of sizeof(SomeStru ct) from the
beginning of the allocated block. This is guaranteed by the Standard
(subject to the caveats I mentioned).

It is never necessary or desirable to cast the value returned by malloc
(unless your name is P J Plauger, which, in your case, presumably it
isn't).

--
Richard Heathfield
"Usenet is a strange place" - dmr 29/7/1999
http://www.cpax.org.uk
email: rjh at the above domain, - www.

[Why Tea]

It is never necessary or desirable to cast the value returned by malloc
(unless your name is P J Plauger, which, in your case, presumably it
isn't).

Thanks for the answer. No, I', not P J :), so no cast for me...

One more question while I'm at it about the memory stuff. Assuming I
have the following code:

SomeStruct *p;
p = malloc(100 + sizeof(SomeStru ct)); /* 100 is not multiples of
sizeof(SomeStru ct) */
/* do something before freeing it */
free(p);

Will the entire memory pointed to by p be released? Does free(p) always
releases multiples of the data structure p points to?

[Richard Heathfield]

Why Tea said:

<snip>

One more question while I'm at it about the memory stuff. Assuming I
have the following code:

SomeStruct *p;
p = malloc(100 + sizeof(SomeStru ct)); /* 100 is not multiples of
sizeof(SomeStru ct) */
/* do something before freeing it */
free(p);

Will the entire memory pointed to by p be released? Does free(p) always
releases multiples of the data structure p points to?

malloc() doesn't allocate data structures. It simply allocates a block of
memory, n bytes in size (where you supply n), and returns a pointer to the
start of that block. In this case, you calculate n like this: 100 +
sizeof(SomeStru ct). But malloc doesn't see that calculation. It only sees
the result. It doesn't know about SomeStruct, let alone sizeof(SomeStru ct).
It only sees 123, or 145, or whatever it is that 100+sizeof(Some Struct)
evaluates to. It will try to allocate that much memory, and return a
pointer to that memory if successful.

When you pass that pointer value to free(), the whole block is freed, and
the pointer value becomes indeterminate.

--
Richard Heathfield
"Usenet is a strange place" - dmr 29/7/1999
http://www.cpax.org.uk
email: rjh at the above domain, - www.

[Richard Tobin]

In article <11************ **********@42g2 000cwt.googlegr oups.com>,
Why Tea <yt****@gmail.c omwrote:

p = malloc(100 + sizeof(SomeStru ct)); /* 100 is not multiples of sizeof(SomeStru ct) */
/* do something before freeing it */

Be sure you know what you're doing here. You can't, for example,
reliably store 100 chars followed by a struct in this memory, because
the alignment of p+100 may not be suitable for the struct.

-- Richard

--
"Considerat ion shall be given to the need for as many as 32 characters
in some alphabets" - X3.4, 1963.

[Why Tea]

Richard Tobin wrote:

In article <11************ **********@42g2 000cwt.googlegr oups.com>,
Why Tea <yt****@gmail.c omwrote:

p = malloc(100 + sizeof(SomeStru ct)); /* 100 is not multiples of sizeof(SomeStru ct) */
/* do something before freeing it */

Be sure you know what you're doing here. You can't, for example,
reliably store 100 chars followed by a struct in this memory, because
the alignment of p+100 may not be suitable for the struct.

Thanks Richard. In fact I was reading someone else's code. The
intention of the code is to have a memory allocation similar to this:

|<- SomeStruct ->|<- UserStruct ->

Hence,
SomeStruct *p;
p = malloc(sizeof(S omeStruct) + sizeof(UserStru ct)); /* UserStruct can
be anything */
...
free(p);

(p+1) points to the beginning of UserStruct, so users can store
anything in there.

My understanding is, the paddings (if any) for memory alignment are
included in the calculation of sizeof(). So the code should work
properly. Is my understanding correct?