Swift：如果将引用类型常量分配给变量，但该变量发生了变化，会发生什么情况？

Question

I am confused on the difference between var and let for reference type in swift.

In the code below, let head is assigned to var current:

 public class ListNode {
     public var val: Int
     public var next: ListNode?
     public init() { self.val = 0; self.next = nil; }
     public init(_ val: Int) { self.val = val; self.next = nil; }
     public init(_ val: Int, _ next: ListNode?) { self.val = val; self.next = next; }
 }

var current = ListNode()
let head = current

current.next = ListNode(3)
current = current.next!

print(current.val) -> return "3"
print(head.val)  -> return "0"
print(head.next?.val) -> return "3"

I don't understand why head.val = 0 and head.next.val = 3 in the end.

I understand that head and current are an instance of a class, therefore they are reference type. They are supposed to be point to the exact same memory address. But it is very confusing to me why

current = current.next!

Doesn't make head also equal to current.next.

Does't head and current point to the same memory address? why can they be different values? If someone tell me, head can't change value because it is a constant, then why does head.next?.val changed to 3?

The answer must be so obvious, because I don't see anyone asking this question. But I am just so lost. Thank you!

Answer 1

You expect reference type variables to work like pointers, but they don't. Reference types ensure that if you change a property of a specific instance, that change will be reflected for all other references to the same instance as well.

However, when you change the instance that a mutable reference points to, that won't change won't propagate to other references pointing to the original instance. The other references will still point to the original instance.