c – 从单链表中删除条目

what happens when *indirect = entry->next; evaluates? I cannot see why it leads to the remove of the certain entry.

我希望你对双指针有清楚的认识1).

假设如下：
节点结构是

typedef struct Node {
    int data;
    struct Node *next;
} linked_list;

链表有5个节点,条目指针指向列表中的第二个节点.内存中的视图将是这样的：

entry -+
   head                          |
      +---+     +-------+     +-------+     +-------+     +-------+     +--------+
      |   |---->| 1 |   |---->| 2 |   |---->| 3 |   |---->| 4 |   |---->| 5 |NULL|
      +---+     +-------+     +-------+     +-------+     +-------+     +--------+

这个说法：

linked_list** indirect = &head;

将使间接指针指向头部.

entry -+
  head                          |
     +---+     +-------+     +-------+     +-------+     +-------+     +--------+
     |   |---->| 1 |   |---->| 2 |   |---->| 3 |   |---->| 4 |   |---->| 5 |NULL|
     +---+     +-------+     +-------+     +-------+     +-------+     +--------+
       ^
       |
     +---+
     |   |
     +---+
   indirect

while循环

while ((*indirect) != entry)

* indirect将给出第一个节点的地址,因为head指向第一个节点,因为entry指向第二个节点,循环条件的计算结果为true,后面的代码将执行：

indirect = &(*indirect)->next;

这将使间接指针指向第一个节点的下一个指针.内存中的视图：

entry -+
   head                          |
      +---+     +-------+     +-------+     +-------+     +-------+     +--------+
      |   |---->| 1 |   |---->| 2 |   |---->| 3 |   |---->| 4 |   |---->| 5 |NULL|
      +---+     +-------+     +-------+     +-------+     +-------+     +--------+
                      ^
                      |
                    +---+
                    |   |
                    +---+
                  indirect

现在将评估while循环条件.因为间接指针现在指向第一个节点的下一个,所以* indirect将给出第二个节点的地址,并且由于条目指向第二个节点,因此循环条件的计算结果为false并且循环退出.
以下代码现在将执行：

*indirect = entry->next;

*间接取消引用第一个节点的下一个节点,现在它被分配了一个节点指向的节点的下一个节点.内存中的视图：

entry -+
   head                          |
      +---+     +-------+     +-------+     +-------+     +-------+     +--------+
      |   |---->| 1 |   |--   | 2 |   |---->| 3 |   |---->| 4 |   |---->| 5 |NULL|
      +---+     +-------+    +-------+     +-------+     +-------+     +--------+
                  *indirect               /
                             +------------+

现在,第一个节点的下一个节点指向列表中的第三个节点,这样就可以从列表中删除第二个节点.

希望这清楚你所有的疑虑.

编辑：

大卫在评论中建议添加一些细节 – 为什么(&);(*间接) – >下一个需要(..)括号？

间接的类型是linked_list **,这意味着它可以保存linked_list *类型的指针的地址.
* indirect将给出linked_list *类型的指针和 – > next将给出它的下一个指针.
但我们不能写* indirect-> next因为运算符的优先级 – >高于一元*运算符.因此,* indirect-> next将被解释为*(indirect-> next),这在语法上是错误的,因为indirect是指向指针的指针.
因此我们需要()围绕*间接.

此外,&(* indirect) – > next将被解释为&((* indirect) – > next),这是下一个指针的地址.

1)如果您不知道双指针的工作原理,请查看以下内容：

让我们举一个例子：

#include <stdio.h>

int main() {
        int a=1,b=2;
        int *p = &a;
        int **pp = &p;

        printf ("1. p : %pn",(void*)p);
        printf ("1. pp : %pn",(void*)pp);
        printf ("1. *p : %dn",*p);
        printf ("1. *pp : %dn",**pp);

        *pp = &b;  // this will change the address to which pointer p pointing to
        printf ("2. p : %pn",(void*)p);
        printf ("2. pp : %pn",(void*)pp);
        printf ("2. *p : %dn",*p);
        printf ("2. *pp : %dn",**pp);

        return 0;
}

在上面的代码中,在这个语句中 – * pp =& b;,你可以看到,如果不直接访问指针p,我们可以使用双指针pp来改变它指向的地址,这指向指针p,因为解除引用双指针pp将给出指针p.

它的输出：

1. p : 0x7ffeedf75a38
1. pp : 0x7ffeedf75a28
1. *p : 1
1. *pp : 1
2. p : 0x7ffeedf75a34   <=========== changed 
2. pp : 0x7ffeedf75a28
2. *p : 2
2. *pp : 2

内存中的视图将是这样的：

//Below in the picture
//100 represents 0x7ffeedf75a38 address
//200 represents 0x7ffeedf75a34 address
//300 represents 0x7ffeedf75a28 address

int *p = &a
      p         a
      +---+     +---+
      |100|---->| 1 |
      +---+     +---+

        int **pp = &p;

      pp        p         a
      +---+     +---+     +---+
      |300|---->|100|---->| 1 |
      +---+     +---+     +---+


*pp = &b;

      pp        p         b
      +---+     +---+     +---+
      |300|---->|200|---->| 2 |
      +---+     +---+     +---+
                ^^^^^     ^^^^^