Go语言自定义结构体指针接收器未更新问题排查

我正在学习Go语言，做单链表实现练习时遇到了问题：实现AddItem和Print函数后，当AddItem返回新指针时程序能正常生成链表，但改成直接更新指针接收器（li = li.next）时，main函数里的ll变量根本没被更新，导致最终链表结果不符合预期。

可正常运行的代码 #

package main

import (
    "fmt"
)

// List represents a singly-linked list that holds
// values of any type.
type List[T any] struct {
    next *List[T]
    val  T
}

func (li *List[T]) AddItem(val T) *List[T] {
    li.next = &List[T]{
        next: nil,
        val:  val,
    }
    li = li.next
    return li
}

func Print[T any](head *List[T]) {
    i := 0
    itr := head
    for itr != nil {
        fmt.Printf("(idx: %d, val: %d) next: %v\n", i, itr.val, itr.next)
        i++
        itr = itr.next
    }
}

func main() {
    ll := &List[int]{
        next: nil,
        val:  7,
    }
    head := ll
    
    ll = ll.AddItem(2)
    ll = ll.AddItem(3)
    ll = ll.AddItem(6)

    Print(head)
}

预期输出 #

(idx: 0, val: 7) next: &{0xc000014270 2}
(idx: 1, val: 2) next: &{0xc000014280 3}
(idx: 2, val: 3) next: &{<nil> 6}
(idx: 3, val: 6) next: <nil>

修改后不符合预期的代码 #

修改AddItem方法去掉返回值：

func (li *List[T]) AddItem(val T) {
    li.next = &List[T]{
        next: nil,
        val:  val,
    }
    li = li.next // 期望更新main里的ll，但实际无效
    fmt.Println("Next:", li) // 这里打印的是正确的新节点，但main里的ll没变
}

修改main函数调用方式：

func main() {
    ll := &List[int]{
        next: nil,
        val:  7,
    }
    head := ll
    
    ll.AddItem(2)
    ll.AddItem(3)
    ll.AddItem(6)
    
    Print(head)
}

实际输出（不符合预期） #

(idx: 0, val: 7) next: &{<nil> 6}
(idx: 1, val: 6) next: <nil>

问题原因 #

Go语言里的指针接收器是按值传递的——当你调用ll.AddItem(...)时，li是ll这个指针的副本，它和ll指向同一个结构体，但li本身是另一个独立变量：

• 修改li.next = ...是有效的：因为li和ll指向同一块内存，修改结构体字段会同步到原对象；
• 但li = li.next只是修改了li这个副本指针的指向，完全不会影响main函数里的ll变量——ll依然指向最初的节点，所以后续调用ll.AddItem(...)时，都是在原节点的next上重复赋值，最后只有最后一次添加的元素能保留。

解决方法 #

方法1：继续使用返回值的方式（最简洁） #

保留你最初的写法，每次添加后用返回的新节点更新ll，让它始终指向链表尾部，后续添加都在尾部操作。

方法2：使用指针的指针作为接收器 #

如果不想返回值，可以把接收器改成**List[T]，这样就能直接修改原指针的指向：

func (li **List[T]) AddItem(val T) {
    // 当前节点的next指向新节点
    (*li).next = &List[T]{
        next: nil,
        val:  val,
    }
    // 更新原指针，让它指向新节点
    *li = (*li).next
}

调用时无需修改代码，Go会自动把*List[T]转为**List[T]。

方法3：给链表结构体添加尾指针 #

在链表结构体里维护一个指向尾部的指针，每次添加直接操作尾指针，不需要更新外部变量：

type List[T any] struct {
    head *List[T]
    tail *List[T]
    val  T
    next *List[T]
}

// 初始化链表
func NewList[T any](val T) *List[T] {
    node := &List[T]{val: val}
    node.head = node
    node.tail = node
    return node
}

func (l *List[T]) AddItem(val T) {
    newNode := &List[T]{val: val}
    l.tail.next = newNode
    l.tail = newNode
}

// 修改Print函数遍历head
func Print[T any](l *List[T]) {
    i := 0
    itr := l.head
    for itr != nil {
        fmt.Printf("(idx: %d, val: %d) next: %v\n", i, itr.val, itr.next)
        i++
        itr = itr.next
    }
}

调用方式：

func main() {
    ll := NewList(7)
    ll.AddItem(2)
    ll.AddItem(3)
    ll.AddItem(6)
    Print(ll)
}

内容的提问来源于stack exchange，提问作者usersina