listing doubly linked list items C

Question

I'm new to C.I am trying to create a doubly linked list where the data field is a structure. But when I output the elements, only the first field of the structure is correctly displayed.

struct n
{
    int a;
    int b;

};

typedef struct _Node {
    struct n *value;
    struct _Node *next;
    struct _Node *prev;
} Node;


typedef struct _DblLinkedList {
    size_t size;
    Node *head;
    Node *tail;
} DblLinkedList;


DblLinkedList* createDblLinkedList() {
    DblLinkedList *tmp = (DblLinkedList*) malloc(sizeof(DblLinkedList));
    tmp->size = 0;
    tmp->head = tmp->tail = NULL;
    return tmp;
}

void pushBack(DblLinkedList *list, struct n *value) {
    Node *tmp = (Node*) malloc(sizeof(Node));
    if (tmp == NULL) {
        exit(3);
    }
    tmp->value = value;
    tmp->next = NULL;
    tmp->prev = list->tail;
    if (list->tail) {
        list->tail->next = tmp;
    }
    list->tail = tmp;

    if (list->head == NULL) {
        list->head = tmp;
    }
    list->size++;
}
void printInt(struct n *value) {
    printf("%d, %d", value->a, value->b);
}
void printDblLinkedList(DblLinkedList *list, void (*fun)(struct n*)) {
    Node *tmp = list->head;
    while (tmp) {
        fun(tmp->value);
        tmp = tmp->next;
        printf("\n");
    }
}

So, I have a few questions. Did I declare the node value field correctly? Am I inserting the node at the end of the list correctly? Am I doing the output of doubly linked list items correctly? And where is my mistake and how to fix it?

Answer 1

Did I declare the node value field correctly?

That depends on what your intention was. In terms of storing a pointer to a struct n: yes.

Am I inserting the node at the end of the list correctly?

Yes.

Am I doing the output of doubly linked list items correctly?

Yes.

And where is my mistake and how to fix it?

The code works from my point-of-view but what can be misleading is how pushBack operates. pushBack takes the struct n pointer as-is and stores it in Node. You did not post the pushBack caller code but the current implementation can caused problems if the caller assumes that the struct n gets copied.

To illustrate that, consider the following:

  struct n value;
  value.a = 1;
  value.b = 2;
  pushBack(list, &value);
  value.a = 3;
  value.b = 4;
  pushBack(list, &value);

By reusing the value, two linked list nodes will effectively contain the same values. Also, the inserted struct n pointer must remain valid throughout the lifetime of the list. So, inserting stack-allocated values (that will be deallocated later by leaving their scope) or freeing dynamically-allocated values too early might lead to incorrect values. As long as the caller knows that, this is not necessarily a problem.

There are usually 3 ways to handle memory ownership:

1. Data structure owns values (just like it owns nodes) and is responsible for freeing them
2. Data structure copies values and is responsible for freeing them
3. Caller owns values and is responsible for freeing them

For a linked list, there's lots of merit in the strategy #3, because a linked list can be created from existing values without any copying or ownership transfer which would most certainly require changes to existing code. That's basically what your code is doing at the moment.