C Linked List Implementation Pointer vs. Pointer-to-Pointer Consistency

Question

To get some practice in C, I'm writing some basic functions for operating on a linked list of ints. I started out with functions that accepted as a "list" a pointer to the head node. Now, I find myself running into more and more occasions when I either need to limit the spec of the function more than I would like, or I need to use a pointer to a pointer to the head node to allow for alteration/removal of the head node in a way that is consistent with the way I alter/remove other nodes.

Is it preferable to have all functions accept a "list" in the same form, as a pointer to a pointer, rather than having some accept just a pointer to the node? Or should I perhaps change the way I think about altering/removing the head node to avoid needing to change the head pointer?

For example, if I write a remove function that removes all instances of the given int, and the head node's value is that int, I see a few obvious choices:

1. I can pass in a pointer to a pointer and move the head pointer to the next node not being removed.

2. I can pass in a pointer and I can move the value of the next node not being removed, say node x, into the head node and remove node x along with any other nodes that hold the value to be removed. This fails in the case that the list consists of only a single node that contains the value, and so I have to limit the spec to exclude this case.

In the case that I pass in a pointer to a pointer for this function, should I now change all other functions to accept a pointer to a pointer?

Are there standards for things like this or is it up to me? (Pretending of course that this code matters in some fashion to someone other than me and would, in that fantasy land, be used by other people without knowledge of the inner workings of the functions, beyond their signatures.)

Answer 1

There are three choices that I can see.

1. Use a "list head" struct that doesn't contain any data, but simply points at "the list" (as pointed out by Jonathan Eunice in a comment, this means you have a conventient place for any extra data you may eventually want to collect and means you no longer need pointers-to-pointers)
2. Use the pointer-to-pointer you have identified
3. Always return the "new" list value and make use of the returned value.

As an example of the third model:

struct list { int val; struct list *next; } struct list *drop_head(struct list *lst) { struct list *rv = lst->next; free(lst); return rv; } void blah() { struct list *my_list; /* imagine interesting code here */ my_list = drop_head(my_list); /* imagine more interesting code here */ } 

Answer 2

I wrote a similar program for the linked list in C, you need to get pointer to pointers in all functions to make it consistent across all function, because removing and create a new head or tail would require a pointer to pointer. However you can make a enum for the tail and head pointers. example from my code:

enum LIST_PTR { LIST_HEAD =0, LIST_TAIL }; struct node { struct node *NextNode; // Pointer to next node int data; // node data. }; void enqueue(struct node** head, struct node** tail,int data); int dequeue(struct node** head, struct node** tail); int getCount(struct node** head, struct node** tail); int destroyList(struct node** head, struct node** tail); 

then you can declare and use or linked list in following manner

struct node* my_list[2]; my_list[0]=my_list[1]=NULL; getCount(&my_list[LIST_HEAD],&my_list[LIST_TAIL]); 

make sure you assign the pointers to NULL or i am telling you by experience, you will have a seg fault of which you will have no idea!