C 中的双向链表：为什么我必须显式地重新分配头部和尾部，即使它们没有改变？

Question

我有一个双向链表，您可以在其中通过指向头节点或尾节点指针的指针添加到头节点或尾节点。

这样你就可以将头指针和尾指针更新为最新的头节点或尾节点的地址。

我有那些 "pointer to pointers" 在它们自己的函数中启动并存储在包含两者的结构中。

当我添加到尾部或头部时，我必须显式保存旧的头部并重新分配它，尾部则相反。否则，结构发生变异，头部也变成尾部，或者尾部变成头部。

我正在尝试了解发生了什么。也许 head/tail 保留结构必须静态/全局定义？

此处来源：

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

typedef struct dcl_node {
  char *content;
  struct dcl_node *next;
  struct dcl_node *prev;
} Node;

Node *create_node (char *content) {
  Node *n = malloc(sizeof(Node));
  n->content = content;
  n->next = NULL;
  n->prev = NULL;
  return n;
}

typedef struct dc_list {
  struct dcl_node **head;
  struct dcl_node **tail;
} DCList ;

DCList *init_list (char *content_head, char *content_tail) {
  Node *head = create_node(content_head);
  Node *tail = create_node(content_tail);
  head->next = tail;
  tail->prev = head;
  DCList *list = malloc(sizeof(DCList));
  list->head = &head;
  list->tail = &tail;
  return list;
}

void insert_head (char *content, DCList *list) {
  Node *old_head = *list->head;
  Node *old_tail = *list->tail; // note the saving here
  Node *node = create_node(content);
  node->next = old_head;
  old_head->prev = node;
  *list->head = node;
  *list->tail = old_tail; // and reassigning here
}

void insert_tail (char *content, DCList *list) {
  Node *old_head = *list->head; // note the saving here
  Node *old_tail = *list->tail;
  Node *node = create_node(content);
  node->prev = old_tail;
  old_tail->next = node;
  *list->head = old_head; // and reassigning here
  *list->tail = node;
}

int main (int argc, char *argv[]) {
  DCList *list = init_list("c", "d");

  insert_head("b", list);

  // If I don't explicitly save and reassign the tail node, 
  // in this case both head and tail would become the "b node".
    printf("head: %s\ntail: %s\n",
      (*list->head)->content, (*list->tail)->content);

  return 0;
}

Answer 1

因为list->head和list->tail是指向init_list函数中局部变量的指针

这些变量在 init_list returns 时被销毁并且可以重新使用它们存储的内存。

巧合的是，当您将它们保存在 insert_head 和 insert_tail 中时，您保存的 head 和 tail 变量（可能！）获得相同的内存地址，因此它们不要被覆盖。否则，旧的 head 可能会被 node 覆盖。

这是一个大概的解释——很难说出编译器实际上在做什么。但关键是 head 和 tail 在 init_list returns 时被销毁，然后你的 list->head 和 list->tail 指向空闲内存可以重复使用。

C 中的双向链表：为什么我必须显式地重新分配头部和尾部，即使它们没有改变？

Doubly linked list in C: Why do I have to explicitly reassign head and tail even when they are not changed?

c

pointers

doubly-linked-list