Pointers 为什么更改指针副本不会影响初始对象_Pointers_Go

Pointers 为什么更改指针副本不会影响初始对象

pointers go

Pointers 为什么更改指针副本不会影响初始对象,pointers,go,Pointers,Go,我学会处理指针，在这个例子中，我不明白为什么将i3重新指定给新的当前对象，并执行“当前=当前”操作。下一步不会影响i3对象。但是，使用相同的地址 func main() { i := &Node{data: 1} i2 := &Node{data: 2, next: i} i3 := &Node{data: 3, next: i2} current := i3 for current.

我学会处理指针，在这个例子中，我不明白为什么将i3重新指定给新的当前对象，并执行“当前=当前”操作。下一步不会影响i3对象。但是，使用相同的地址

func main() {

        i := &Node{data: 1}
        i2 := &Node{data: 2, next: i}
        i3 := &Node{data: 3, next: i2}

        current := i3
        for current.next != nil {
                current = current.next
        }
        log.Println(current)
        log.Println(i3)
        /*
        2020/06/03 12:19:23 &{1 <nil>}
        2020/06/03 12:19:23 &{3 0xc42000e1f0}
        */

}

type Node struct {
        data int 
        next *Node
}

func main（）{
i:=&节点{数据：1}
i2:=&节点{数据：2，下一个：i}
i3:=&节点{数据：3，下一个：i2}
电流：=i3
对于当前。下一步！=nil{
当前=当前。下一步
}
log.Println（当前）
log.Println（i3）
/*
2020/06/03 12:19:23 &{1 }
2020/06/03 12:19:23&{3 0xc42000e1f0}
*/
}
类型节点结构{
数据整型
下一个*节点
}

然而，如果我不使用i3对象的副本，那么该对象在循环中会得到很好的修改

func main() {

        i := &Node{data: 1}
        i2 := &Node{data: 2, next: i}
        i3 := &Node{data: 3, next: i2}

        log.Println(i3)
        /*
                2020/06/03 12:22:05 &{3 0xc42000e1f0}
        */
        for i3.next != nil {
                i3 = i3.next
        }
        log.Println(i3)
        /*
                2020/06/03 12:22:05 &{1 <nil>}
        */

}

func main（）{
i:=&节点{数据：1}
i2:=&节点{数据：2，下一个：i}
i3:=&节点{数据：3，下一个：i2}
log.Println（i3）
/*
2020/06/03 12:22:05&{3 0xc42000e1f0}
*/
对于i3.next！=零{
i3=i3.next
}
log.Println（i3）
/*
2020/06/03 12:22:05 &{1 }
*/
}

在第一个示例中，短变量声明：

current := i3

创建指针类型的名为

current

的新变量。它是一个不同于

i3

的变量，但具有相同的指针值

循环仅修改（分配）当前变量，因此存储在

i3

中的指针永远不会更改。因此，在循环之后，

i3

仍然指向

data=3

的节点，并且

current

将是最后一个节点，即

data=1

在第二个示例中，您没有创建

当前

变量，而是修改（分配）了

i3

变量。因此，在循环之后，它将指向最后一个

data=1

的节点。在这两种情况下都不会修改节点对象，只修改

当前

或

i3

变量。

在第一个示例中，短变量声明：

current := i3

创建指针类型的名为

current

的新变量。它是一个不同于

i3

的变量，但具有相同的指针值

循环仅修改（分配）当前变量，因此存储在

i3

中的指针永远不会更改。因此，在循环之后，

i3

仍然指向

data=3

的节点，并且

current

将是最后一个节点，即

data=1

在第二个示例中，您没有创建

当前

变量，而是修改（分配）了

i3

变量。因此，在循环之后，它将指向最后一个

data=1

的节点。在这两种情况下都不会修改节点对象，只修改

current

或

i3

变量。

在第一个示例中，您创建了一个指针

current

，它将具有与

i3

相同的值（结构

节点的地址{data:3，next:i2}

）

在for循环中执行

current=current.next

语句时，只更改指针的值，而不更改地址后面的值。只替换指针中存储的地址

如果您遵循迭代：

0., current -> Node{data: 3, next: i2}     
1., current -> Node{data: 2, next: i}     
2., current -> Node{data: 1}

0., i3 -> Node{data: 3, next: i2}     
1., i3 -> Node{data: 2, next: i}     
2., i3 -> Node{data: 1}

其他指针将保持不变

i -> Node{data: 1}      
i2 -> Node{data: 2, next: i}     
i3 -> Node{data: 3, next: i2}

i -> Node{data: 1}      
i2 -> Node{data: 2, next: i}

在第二种情况下，您也可以执行同样的操作，但是现在您可以更改存储在

i3

指针中的地址，而不是

current

指针。如果您遵循迭代：

0., current -> Node{data: 3, next: i2}     
1., current -> Node{data: 2, next: i}     
2., current -> Node{data: 1}

0., i3 -> Node{data: 3, next: i2}     
1., i3 -> Node{data: 2, next: i}     
2., i3 -> Node{data: 1}

其他指针将保持不变

i -> Node{data: 1}      
i2 -> Node{data: 2, next: i}     
i3 -> Node{data: 3, next: i2}

i -> Node{data: 1}      
i2 -> Node{data: 2, next: i}

当然，您将在内存中的某个位置拥有一个对象，而无法访问它（节点{data:3，next:i2}）

在第一个示例中，您创建了一个指针

current

，它将具有与

i3

相同的值（结构

节点{data:3，next:i2}

）

在for循环中执行

current=current.next

语句时，只更改指针的值，而不更改地址后面的值。只替换指针中存储的地址

如果您遵循迭代：

0., current -> Node{data: 3, next: i2}     
1., current -> Node{data: 2, next: i}     
2., current -> Node{data: 1}

0., i3 -> Node{data: 3, next: i2}     
1., i3 -> Node{data: 2, next: i}     
2., i3 -> Node{data: 1}

其他指针将保持不变

i -> Node{data: 1}      
i2 -> Node{data: 2, next: i}     
i3 -> Node{data: 3, next: i2}

i -> Node{data: 1}      
i2 -> Node{data: 2, next: i}

在第二种情况下，您也可以执行同样的操作，但是现在您可以更改存储在

i3

指针中的地址，而不是

current

指针。如果您遵循迭代：

0., current -> Node{data: 3, next: i2}     
1., current -> Node{data: 2, next: i}     
2., current -> Node{data: 1}

0., i3 -> Node{data: 3, next: i2}     
1., i3 -> Node{data: 2, next: i}     
2., i3 -> Node{data: 1}

其他指针将保持不变

i -> Node{data: 1}      
i2 -> Node{data: 2, next: i}     
i3 -> Node{data: 3, next: i2}

i -> Node{data: 1}      
i2 -> Node{data: 2, next: i}

当然，您将在内存中的某个位置拥有一个对象，而无法访问它（节点{data:3，next:i2}）

current

和

i3

都是指针

current:= i3

复制指针意味着现在

current

将指向

i3

指向的同一地址

指针的副本与它复制时所使用的任何关系都不相关，只指向相同的值。因此，修改当前

不会对i3
产生任何影响
你可以这样做
current := &i3
for (*current).next != nil {
    *current = (*current).next
}

现在current
是i3
的指针，现在如果您更改将影响i3
current
和i3
的当前指针值，这两个都是指针
current:= i3

复制指针意味着现在current
将指向i3
指向的同一地址
指针的副本与它复制时所使用的任何关系都不相关，只指向相同的值。因此，修改当前不会对i3
产生任何影响
你可以这样做
current := &i3
for (*current).next != nil {
    *current = (*current).next
}

现在current
是i3
的指针，现在如果您更改将影响i3
的当前指针值