Yet another free() question.

[lawtrevor]

I have a question regarding the use of free() based on some code I need
to decipher:

{
struct A {<A fields>};
struct B {<A fields+ <Bfields>};

typedef struct A Aobj;
typedef struct B Bobj;

Aobj *ptrToA = (struct A*) calloc(1,sizeof (struct B));

free(ptrToA);
}

Will this free the entire memory block of size sizeof(struct B), or
only a block starting at ptrToA of size sizeof(struct A)? The posts I
have read strongly suggest this will, as probably intended, free the
entire block produced by calloc(), but in those posts it seems
sizeof(Aobj) == N*sizeof(Bobj), i.e. the size of the allocated block is
an integer multiple of the dereferenced type of the pointer to which
the allocated block's void pointer is cast (Don't know how to express
this well). Such would be the case when allocating a single instance
of an object or an array of the same objects on the heap. Just want to
make sure what is done above is safe (assuming the type interpretation
of the allocated block elsewhere is correct.)

Thank you for your time.

[Spiros Bousbouras]

la*******@gmail .com wrote:

I have a question regarding the use of free() based on some code I need
to decipher:

{
struct A {<A fields>};
struct B {<A fields+ <Bfields>};

typedef struct A Aobj;
typedef struct B Bobj;

Aobj *ptrToA = (struct A*) calloc(1,sizeof (struct B));

free(ptrToA);
}

Will this free the entire memory block of size sizeof(struct B), or
only a block starting at ptrToA of size sizeof(struct A)? The posts I
have read strongly suggest this will, as probably intended, free the
entire block produced by calloc(),

Yes , that's what it will do. It is worth noting that if the
calloc succeeded then it allocated memory which is *at
least* as large as sizeof(struct B) , it doesn't have to be
exactly sizeof(struct B).

but in those posts it seems
sizeof(Aobj) == N*sizeof(Bobj), i.e. the size of the allocated block is
an integer multiple of the dereferenced type of the pointer to which
the allocated block's void pointer is cast (Don't know how to express
this well).

I will guess that by "dereferenc ed type of the pointer" you
mean the type of object the pointer points to. In any case
whether sizeof(Aobj) == N*sizeof(Bobj) holds or whether
sizeof(*Aobj) == N*sizeof(*Bobj) holds is irrelevant , the
free() will free all the memory (if any) which was allocated
by calloc.

Such would be the case when allocating a single instance
of an object or an array of the same objects on the heap.

Since the presence of a heap is up to an implementation
it's best not use the term. If you mean memory obtained
through the malloc family of functions then that's what
you should say.

Having said that , which case are you referring to ? The
formula sizeof(Aobj) == N*sizeof(Bobj) you gave mentions
2 different object types.

Just want to
make sure what is done above is safe (assuming the type interpretation
of the allocated block elsewhere is correct.)

I don't know what "the type interpretation of the
allocated block" is. mallocing memory and freeing
it right away is safe but obviously pointless. Whether
your code is safe depends on what's happening between
the calloc() and the free().

[Keith Thompson]

la*******@gmail .com writes:

I have a question regarding the use of free() based on some code I need
to decipher:

{
struct A {<A fields>};
struct B {<A fields+ <Bfields>};

typedef struct A Aobj;
typedef struct B Bobj;

Aobj *ptrToA = (struct A*) calloc(1,sizeof (struct B));

free(ptrToA);
}

Will this free the entire memory block of size sizeof(struct B), or
only a block starting at ptrToA of size sizeof(struct A)? The posts I
have read strongly suggest this will, as probably intended, free the
entire block produced by calloc(), but in those posts it seems
sizeof(Aobj) == N*sizeof(Bobj), i.e. the size of the allocated block is
an integer multiple of the dereferenced type of the pointer to which
the allocated block's void pointer is cast (Don't know how to express
this well). Such would be the case when allocating a single instance
of an object or an array of the same objects on the heap. Just want to
make sure what is done above is safe (assuming the type interpretation
of the allocated block elsewhere is correct.)

Yes.

The malloc/calloc/realloc/free subsystem does not, and cannot,
keep track of what you do with the newly allocated pointer after
its value is returned to you. Suppose sizeof(struct A) == 10,
and sizeof(struct b) == 20. In your code, calloc (if successful)
simply returns a void* pointer to 20 bytes of newly allocated memory;
it has no idea that the value 20 was computed as "sizeof(str uct B),
or that you then converted the result from void* to struct A*.

When you call free(PtrToA), free() sees only an argument of type
void*, which happens to have the same value as what was returned by
calloc(), so it frees 20 bytes.

The sizeof, the cast, and the assignment are entirely invisible to
calloc() and free(), and cannot affect their behavior. So as far as
calloc() and free() are concerned, your code is equivalent to:

void *ptr = calloc(1, 20);
free(ptr);

Incidentally, the standard doesn't *quite* guarantee that the initial
fields of your struct A and struct B will be laid out consistently,
unless you happen to declare a union of the two types, though it's
difficult to imagine an implementation in which they wouldn't match.
You might consider making the first member of struct B be of type
struct A, rather than duplicating all the fields explicitly; this
would also avoid any errors that might be introduced by writing the
same sequence of member declarations twice,

--
Keith Thompson (The_Other_Keit h) ks***@mib.org <http://www.ghoti.net/~kst>
San Diego Supercomputer Center <* <http://users.sdsc.edu/~kst>
We must do something. This is something. Therefore, we must do this.

[Spiros Bousbouras]

Keith Thompson wrote:

Incidentally, the standard doesn't *quite* guarantee that the initial
fields of your struct A and struct B will be laid out consistently,
unless you happen to declare a union of the two types, though it's
difficult to imagine an implementation in which they wouldn't match.
You might consider making the first member of struct B be of type
struct A, rather than duplicating all the fields explicitly; this
would also avoid any errors that might be introduced by writing the
same sequence of member declarations twice,

Since what is returned by calloc() is guaranteed to
be properly alligned for any type I don't see what
might go wrong even in theory. Unless you're saying
that sizeof(struct A) may be larger than sizeof(struct B).

[David T. Ashley]

<la*******@gmai l.comwrote in message
news:11******** **************@ 38g2000cwa.goog legroups.com...

>I have a question regarding the use of free() based on some code I need
to decipher:

{
struct A {<A fields>};
struct B {<A fields+ <Bfields>};

typedef struct A Aobj;
typedef struct B Bobj;

Aobj *ptrToA = (struct A*) calloc(1,sizeof (struct B));

free(ptrToA);
}

Will this free the entire memory block of size sizeof(struct B), or
only a block starting at ptrToA of size sizeof(struct A)?

malloc(), calloc(), and free() are block-oriented only. They operate only
in terms of a starting address and a length. There is no type information
involved.

The code in calloc() has no way to determine what calculations went into the
parameters it was passed. They are just integers.

The whole block gets free()'d.

[Fred Kleinschmidt]

<la*******@gmai l.comwrote in message
news:11******** **************@ 38g2000cwa.goog legroups.com...

>I have a question regarding the use of free() based on some code I need
to decipher:

{
struct A {<A fields>};
struct B {<A fields+ <Bfields>};

typedef struct A Aobj;
typedef struct B Bobj;

Aobj *ptrToA = (struct A*) calloc(1,sizeof (struct B));

free(ptrToA);
}

Will this free the entire memory block of size sizeof(struct B), or
only a block starting at ptrToA of size sizeof(struct A)?

It will free the entire block that was allocated.
The signature of free is
void free( void *ptr )
It knows only that it was passed a pointer. It will free the memory
that was allocated by the malloc/calloc/realloc call, regardless of what
that pointer may have been cast to.

Note that
Aobj *ptrToA = (struct A*) calloc(1,sizeof (struct B));

is equivalent to
Aobj *ptrTob = calloc(1,sizeof (struct B));
Aobj *ptrToA = (struct A*) ptrTob;
--
Fred L. Kleinschmidt
Boeing Associate Technical Fellow
Technical Architect, Software Reuse Project

[Richard]

"David T. Ashley" <dt*@e3ft.comwr ites:

<la*******@gmai l.comwrote in message
news:11******** **************@ 38g2000cwa.goog legroups.com...

>>I have a question regarding the use of free() based on some code I need
to decipher:

{
struct A {<A fields>};
struct B {<A fields+ <Bfields>};

typedef struct A Aobj;
typedef struct B Bobj;

Aobj *ptrToA = (struct A*) calloc(1,sizeof (struct B));

free(ptrToA) ;
}

Will this free the entire memory block of size sizeof(struct B), or
only a block starting at ptrToA of size sizeof(struct A)?

malloc(), calloc(), and free() are block-oriented only. They operate only
in terms of a starting address and a length. There is no type information
involved.

Can someone explain again why people keep saying (in this NG) that ints or pointers
to chars etc might be stored in different memory blocks? And if they
are, how would one possibly use malloc?

[Spiros Bousbouras]

Richard wrote:

"David T. Ashley" <dt*@e3ft.comwr ites:

<la*******@gmai l.comwrote in message
news:11******** **************@ 38g2000cwa.goog legroups.com...

>I have a question regarding the use of free() based on some code I need
to decipher:

{
struct A {<A fields>};
struct B {<A fields+ <Bfields>};

typedef struct A Aobj;
typedef struct B Bobj;

Aobj *ptrToA = (struct A*) calloc(1,sizeof (struct B));

free(ptrToA);
}

Will this free the entire memory block of size sizeof(struct B), or
only a block starting at ptrToA of size sizeof(struct A)?

malloc(), calloc(), and free() are block-oriented only. They operate only
in terms of a starting address and a length. There is no type information
involved.

Can someone explain again why people keep saying (in this NG) that ints or pointers
to chars etc might be stored in different memory blocks? And if they
are, how would one possibly use malloc?

I don't know what "stored in different memory blocks"
means or whether it has been said in some thread but
noone has said it in this thread.

[Keith Thompson]

"Spiros Bousbouras" <sp****@gmail.c omwrites:

Keith Thompson wrote:

>Incidentally , the standard doesn't *quite* guarantee that the initial
fields of your struct A and struct B will be laid out consistently,
unless you happen to declare a union of the two types, though it's
difficult to imagine an implementation in which they wouldn't match.
You might consider making the first member of struct B be of type
struct A, rather than duplicating all the fields explicitly; this
would also avoid any errors that might be introduced by writing the
same sequence of member declarations twice,

Since what is returned by calloc() is guaranteed to
be properly alligned for any type I don't see what
might go wrong even in theory. Unless you're saying
that sizeof(struct A) may be larger than sizeof(struct B).

Yes, sizeof(struct A) may theoretically, given a sufficiently insane
implementation, be larger than sizeof(struct B), but that's not what I
had in mind.

The code in question was:
| {
| struct A {<A fields>};
| struct B {<A fields+ <Bfields>};
|
| typedef struct A Aobj;
| typedef struct B Bobj;
|
| Aobj *ptrToA = (struct A*) calloc(1,sizeof (struct B));
|
| free(ptrToA);
| }

I assumed that the reason for declaring struct B that way was to allow
the initial part of a struct B object to be treated as a struct A.
That's the only reason I can think of to allocate sizeof(struct B)
bytes.

There's one other thing I should mention here. calloc() initializes
the allocated memory to all-bits-zero. If struct A or struct B
contains members of some pointer or floating-point type, there's no
guarantee that this will set them to null pointers or 0.0,
respectively. It may be safer to use malloc() and then initialize the
members explicitly.

For example (ignoring the struct A vs. struct B business):

struct foo { /* ... */ };
const struct foo foo_zero = { 0 };
struct foo *ptr_to_foo = malloc(sizeof *ptr_to_foo);
if (ptr_to_foo == NULL) { /* OOPS! */ }
*ptr_to_foo = foo_zero;

--
Keith Thompson (The_Other_Keit h) ks***@mib.org <http://www.ghoti.net/~kst>
San Diego Supercomputer Center <* <http://users.sdsc.edu/~kst>
We must do something. This is something. Therefore, we must do this.

[Keith Thompson]

Richard <rg****@gmail.c omwrites:

"David T. Ashley" <dt*@e3ft.comwr ites:

><la*******@gma il.comwrote in message
news:11******* *************** @38g2000cwa.goo glegroups.com.. .

>>>I have a question regarding the use of free() based on some code I need
to decipher:

{
struct A {<A fields>};
struct B {<A fields+ <Bfields>};

typedef struct A Aobj;
typedef struct B Bobj;

Aobj *ptrToA = (struct A*) calloc(1,sizeof (struct B));

free(ptrToA );
}

Will this free the entire memory block of size sizeof(struct B), or
only a block starting at ptrToA of size sizeof(struct A)?

malloc(), calloc(), and free() are block-oriented only. They operate only
in terms of a starting address and a length. There is no type information
involved.

Can someone explain again why people keep saying (in this NG) that
ints or pointers to chars etc might be stored in different memory
blocks? And if they are, how would one possibly use malloc?

I don't think anyone has said so in this thread, particularly in the
article to which you replied. I think David was referring to the
"block" of memory allocated by each call to calloc or malloc.

--
Keith Thompson (The_Other_Keit h) ks***@mib.org <http://www.ghoti.net/~kst>
San Diego Supercomputer Center <* <http://users.sdsc.edu/~kst>
We must do something. This is something. Therefore, we must do this.