structure defintion vs declaration question

[Chad]

Given the following.....

#include <stdlib.h>
#include <stdio.h>

struct node {
int data;
struct node *next;
};

int main(void)
{
struct node* head;

head = malloc(sizeof(s truct node));
head->data = 1;
head->next = NULL;

head = head->next;

free(head);

return 0;
}
Is struct node *next defintion or declaration?

[vippstar]

On Aug 29, 4:24 am, Chad <cdal...@gmail. comwrote:

Given the following.....

#include <stdlib.h>
#include <stdio.h>

struct node {
int data;
struct node *next;

};

int main(void)
{
struct node* head;

head = malloc(sizeof(s truct node));
head->data = 1;
head->next = NULL;

head = head->next;

free(head);

return 0;

}

Is struct node *next defintion or declaration?

It's a declaration.
See 6.7.2.1

[Anand Hariharan]

On Thu, 28 Aug 2008 18:24:53 -0700, Chad <cd*****@gmail. comwrote:

Given the following.....

#include <stdlib.h>
#include <stdio.h>

struct node {
int data;
struct node *next;
};

int main(void)
{
struct node* head;

head = malloc(sizeof(s truct node));
head->data = 1;
head->next = NULL;

head = head->next;

free(head);

return 0;
}
Is struct node *next defintion or declaration?

After noting vippstar's response to your immediate question ...
.... hope you are aware that your code is leaking memory.

Also, I'd suggest you review the currently active thread 'Pointer
dereference rather than sizeof' and see if you might reconsider how you
wrote your malloc statement.

- Anand

[Richard Heathfield]

Chad said:

Given the following.....

#include <stdlib.h>
#include <stdio.h>

struct node {
int data;
struct node *next;
};

int main(void)
{
struct node* head;

head = malloc(sizeof(s truct node));

Better: head = malloc(sizeof *head);

Don't assume malloc succeeded - *check* that it succeeded, and take
appropriate action if it failed.

head->data = 1;
head->next = NULL;

head = head->next;

free(head);

return 0;
}
Is struct node *next defintion or declaration?

It's part of a type definition. The grammar calls it a declarator:

struct-or-union-specifier:
struct-or-union identifier<opt{
struct-declaration-list }
struct-or-union identifier

struct-or-union:
struct
union

struct-declaration-list:
struct-declaration
struct-declaration-list struct-declaration

struct-declaration:
specifier-qualifier-list struct-declarator-list ;

specifier-qualifier-list:
type-specifier specifier-qualifier-list<opt>
type-qualifier specifier-qualifier-list<opt>

struct-declarator-list:
struct-declarator
struct-declarator-list , struct-declarator

struct-declarator:
declarator
declarator<opt: constant-expression
--
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

[Chad]

On Aug 28, 6:45 pm, Anand Hariharan <znvygb.nanaq.u nevun...@tznvy. pbz>
wrote:

On Thu, 28 Aug 2008 18:24:53 -0700, Chad <cdal...@gmail. comwrote:

Given the following.....

#include <stdlib.h>
#include <stdio.h>

struct node {
int data;
struct node *next;
};

int main(void)
{
struct node* head;

head = malloc(sizeof(s truct node));
head->data = 1;
head->next = NULL;

head = head->next;

free(head);

return 0;
}

Is struct node *next defintion or declaration?

After noting vippstar's response to your immediate question ...
... hope you are aware that your code is leaking memory.

Also, I'd suggest you review the currently active thread 'Pointer
dereference rather than sizeof' and see if you might reconsider how you
wrote your malloc statement.

Okay, how is the code leaking memory? I should see it, but for some
reason, I don't.

[vippstar]

On Aug 29, 4:59 am, Chad <cdal...@gmail. comwrote:

On Aug 28, 6:45 pm, Anand Hariharan <znvygb.nanaq.u nevun...@tznvy. pbz>
wrote:

On Thu, 28 Aug 2008 18:24:53 -0700, Chad <cdal...@gmail. comwrote:

Given the following.....

#include <stdlib.h>
#include <stdio.h>

struct node {
int data;
struct node *next;
};

int main(void)
{
struct node* head;

head = malloc(sizeof(s truct node));
head->data = 1;
head->next = NULL;

head = head->next;

free(head);

return 0;
}

Is struct node *next defintion or declaration?

After noting vippstar's response to your immediate question ...
... hope you are aware that your code is leaking memory.

Also, I'd suggest you review the currently active thread 'Pointer
dereference rather than sizeof' and see if you might reconsider how you
wrote your malloc statement.

Okay, how is the code leaking memory? I should see it, but for some
reason, I don't.

I did not review your code, just answered your question.
However, your code practically does this:

p = malloc();
/* ... */
p = NULL;
free(p);

(note: free(NULL) is defined to do nothing)

Not only you leak memory, but you fail to check the return value of
malloc, so you are also possibly dereferencing a null pointer.

[Richard Heathfield]

Chad said:

On Aug 28, 6:45 pm, Anand Hariharan <znvygb.nanaq.u nevun...@tznvy. pbz>
wrote:

>On Thu, 28 Aug 2008 18:24:53 -0700, Chad <cdal...@gmail. comwrote:

Given the following.....

#include <stdlib.h>
#include <stdio.h>

struct node {
int data;
struct node *next;
};

int main(void)
{
struct node* head;

head = malloc(sizeof(s truct node));
head->data = 1;
head->next = NULL;

head = head->next;

free(head);

return 0;
}

Is struct node *next defintion or declaration?

After noting vippstar's response to your immediate question ...
... hope you are aware that your code is leaking memory.

<snip>

Okay, how is the code leaking memory? I should see it, but for some
reason, I don't.

head->next = NULL; /* fine, nothing wrong with this. */
head = head->next; /* since head->next is NULL, head is now NULL too,
and you no longer have a record of where your
allocated block is stored. That's a memory leak. */
free(head); /* equivalent to free(NULL) because head is NULL -
this is legal, but does nothing useful. */

--
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

[pete]

Chad wrote:

On Aug 28, 6:45 pm, Anand Hariharan <znvygb.nanaq.u nevun...@tznvy. pbz>
wrote:

>On Thu, 28 Aug 2008 18:24:53 -0700, Chad <cdal...@gmail. comwrote:

>>Given the following.....
#include <stdlib.h>
#include <stdio.h>
struct node {
int data;
struct node *next;
};
int main(void)
{
struct node* head;
head = malloc(sizeof(s truct node));
head->data = 1;
head->next = NULL;
head = head->next;
free(head);
return 0;
}
Is struct node *next defintion or declaration?

After noting vippstar's response to your immediate question ...
... hope you are aware that your code is leaking memory.

Also, I'd suggest you review the currently active thread 'Pointer
dereference rather than sizeof' and see if you might reconsider how you
wrote your malloc statement.

Okay, how is the code leaking memory? I should see it, but for some
reason, I don't.

head = head->next;
free(head);

--
pete

[Jack Klein]

On Thu, 28 Aug 2008 18:59:59 -0700 (PDT), Chad <cd*****@gmail. com>
wrote in comp.lang.c:

On Aug 28, 6:45 pm, Anand Hariharan <znvygb.nanaq.u nevun...@tznvy. pbz>
wrote:

On Thu, 28 Aug 2008 18:24:53 -0700, Chad <cdal...@gmail. comwrote:

Given the following.....

#include <stdlib.h>
#include <stdio.h>

struct node {
int data;
struct node *next;
};

int main(void)
{
struct node* head;

head = malloc(sizeof(s truct node));

If the call to malloc() above succeeds, head now contains the address
of the allocated memory.

head->data = 1;
head->next = NULL;

The two statements above store data into the allocated memory that
head points to. This is just fine if the malloc() call succeeded,
which, as Richard pointed out, you did not check for.

head = head->next;

The statement above changes the contents of head. You overwrite the
address of the allocated memory with a null pointer. Since you have
no other copy of the address returned by malloc(), and you just over
wrote the one copy that you did have, you have lost the address. It's
gone, and there's no way y0u can get it back.

free(head);

The statement above calls free() with a null pointer. That's
perfectly valid and does absolutely nothing. But you haven't free'd
the memory you allocated, and you can't because you lost the pointer
to it.

return 0;
}

Is struct node *next defintion or declaration?

After noting vippstar's response to your immediate question ...
... hope you are aware that your code is leaking memory.

Also, I'd suggest you review the currently active thread 'Pointer
dereference rather than sizeof' and see if you might reconsider how you
wrote your malloc statement.

Okay, how is the code leaking memory? I should see it, but for some
reason, I don't.

See detailed explanation above.

--
Jack Klein
Home: http://JK-Technology.Com
FAQs for
comp.lang.c http://c-faq.com/
comp.lang.c++ http://www.parashift.com/c++-faq-lite/
alt.comp.lang.l earn.c-c++
http://www.club.cc.cmu.edu/~ajo/docs/FAQ-acllc.html