Go语言中接口与零大小结构体指针的比较行为解析

package main

import "fmt"

type fake struct {
}

func main() {
    f := func() interface{} {
        return &fake{} // 返回一个指向fake结构体的指针
    }

    one := f() // one 是一个接口值，其动态类型是 *fake，动态值是指向一个 fake{} 的指针
    two := f() // two 也是一个接口值，其动态类型是 *fake，动态值是指向另一个 fake{} 的指针

    fmt.Println("Are equal?: ", one == two) // 比较两个接口值
    fmt.Printf("Address of one: %p\n", one)
    fmt.Printf("Address of two: %p\n", two)
}

package main

import "fmt"

type fakeWithField struct {
    id int // 添加一个字段
}

func main() {
    f := func() interface{} {
        return &fakeWithField{}
    }

    one := f()
    two := f()

    fmt.Println("Are equal?: ", one == two) // 结果将是 false
    fmt.Printf("Address of one: %p\n", one)
    fmt.Printf("Address of two: %p\n", two)
}

package main

import "fmt"

type uniqueFake int // 使用 int 作为底层类型

func main() {
    var counter uniqueFake // 定义一个计数器
    f := func() interface{} {
        counter++         // 每次调用递增
        return counter    // 返回递增后的值
    }

    one := f()
    two := f()

    fmt.Println("Are equal?: ", one == two) // 结果将是 false
    fmt.Printf("Value of one: %v\n", one)
    fmt.Printf("Value of two: %v\n", two)
}

package main

import (
    "fmt"
    "sync/atomic" // 用于原子操作，确保计数器并发安全
)

type identifiableFake struct {
    ID uint64
}

var globalIDCounter uint64

func main() {
    f := func() interface{} {
        newID := atomic.AddUint64(&globalIDCounter, 1) // 原子递增ID
        return &identifiableFake{ID: newID}
    }

    one := f() // one 的动态值是指向 {ID: 1} 的指针
    two := f() // two 的动态值是指向 {ID: 2} 的指针

    // 此时 one 和 two 都是 *identifiableFake 类型，但它们指向的结构体实例本身是不同的
    // 而且即使它们是零大小结构体，因为它们拥有不同的ID字段，其“语义”上的唯一性也得到了保证。
    // 在本例中，因为 identifiableFake 有字段，所以指针本身就会不同。
    fmt.Println("Are equal?: ", one == two) // 结果将是 false
    fmt.Printf("Instance one: %+v\n", one)
    fmt.Printf("Instance two: %+v\n", two)
}