using free with a casted pointer..

hello everybody! I have one doubt.. Can free() be used with a casted pointer? My situation:
I have these 2 structs which implement a doubly-linked list:

Code:

---

struct list_head{
        struct list_head *next;
        struct list_head *prev;
};
typedef struct list_head ListHead;
typedef ListHead *ListHeadPtr;

struct node{
        struct list_head lh;
        int pid;
};
typedef struct node Node;
typedef Node *NodePtr;

---

and I have to implement my function to delete from list:

Code:

---

void delete_node (ListHeadPtr head, ListHeadPtr node)
{
        (node->prev)->next=node->next;
        (node->next)->prev=node->prev;
        free((NodePtr)node);
}

---

is this ok? otherwise i could write the least general:

Code:

---

void delete_node (ListHeadPtr head, NodePtr node)
{
        ((node->lh).prev)->next = (node->lh).next;
        ((node->lh).next)->prev = (node->lh).prev;
        free(node);
}

---

which one is better in your opinion?thanks!

For C, I actually don't think it matters in the least, seeing as free takes a void* pointer.
Btw, avoid typedef-ing pointer types. They get confusing to read.

I would prefer you write one function that can properly unhook and delete a node from anywhere in the list.

Code:

---

ListHeadPtr delete_node (ListHeadPtr head, NodePtr node)
{
  if (node->lh == head) {
    head->next = node->lh->next;
    head->prev = NULL;
  }
  else if (node->lh->next == NULL) {
    node->lh->prev->next = NULL;
  }
  else {
    node->lh->next->prev = node->lh->prev;
    node->lh->prev->next = node->lh->next;
  }
  free(node);
  return head;
}

---

I believe that's correct... but don't take my word for it. Debug it yourself.

As Elysia says, as long as what you pass in is a pointer of some type and has the same value as you got out of malloc, it doesn't matter what type the pointer is.

It is, again, as Elysia says, a different story in C++, when using delete, where a destructor gets involved in the deleting process. But in C, any old pointer will do fine. malloc/free uses some extra data that is outside of the data you actually used to indicate what the original size you allocated was.

The danger would be if you make a mistake and free something that wasn't allocated (or a pointer in the middle of a previously allocated block) - that will lead to all manner of problems.

--
Mats