Go语言中如何判断两个切片是否引用同一内存起始地址

sliceA := make([]byte, 10) // sliceA 指向一个长度为10的底层数组
sliceC := sliceA[:]        // sliceC 与 sliceA 共享同一个底层数组，并从相同位置开始
sliceD := sliceA[1:2]      // sliceD 与 sliceA 共享同一个底层数组，但从不同位置开始

import (
    "fmt"
    "reflect"
)

func main() {
    sliceA := make([]byte, 10) // 创建一个长度为10的字节切片

    // 示例1：两个切片引用相同的内存起始位置
    sliceC := sliceA[:] // sliceC 是 sliceA 的完整切片，起始位置相同
    fmt.Printf("sliceA 的起始地址: %v\n", reflect.ValueOf(sliceA).Pointer())
    fmt.Printf("sliceC 的起始地址: %v\n", reflect.ValueOf(sliceC).Pointer())
    fmt.Printf("sliceA 和 sliceC 是否引用同一内存起始地址? %t\n", 
               reflect.ValueOf(sliceA).Pointer() == reflect.ValueOf(sliceC).Pointer())
    // 预期输出：true

    fmt.Println("--------------------")

    // 示例2：两个切片引用不同的内存起始位置，但共享底层数组
    sliceD := sliceA[1:] // sliceD 从 sliceA 的第二个元素开始
    fmt.Printf("sliceA 的起始地址: %v\n", reflect.ValueOf(sliceA).Pointer())
    fmt.Printf("sliceD 的起始地址: %v\n", reflect.ValueOf(sliceD).Pointer())
    fmt.Printf("sliceA 和 sliceD 是否引用同一内存起始地址? %t\n", 
               reflect.ValueOf(sliceA).Pointer() == reflect.ValueOf(sliceD).Pointer())
    // 预期输出：false

    fmt.Println("--------------------")

    // 示例3：两个不同的切片，但恰好从底层数组的同一位置开始
    sliceE := sliceA[1:] // sliceE 从 sliceA 的第二个元素开始
    sliceF := sliceA[1:] // sliceF 也从 sliceA 的第二个元素开始
    fmt.Printf("sliceE 的起始地址: %v\n", reflect.ValueOf(sliceE).Pointer())
    fmt.Printf("sliceF 的起始地址: %v\n", reflect.ValueOf(sliceF).Pointer())
    fmt.Printf("sliceE 和 sliceF 是否引用同一内存起始地址? %t\n", 
               reflect.ValueOf(sliceE).Pointer() == reflect.ValueOf(sliceF).Pointer())
    // 预期输出：true

    fmt.Println("--------------------")

    // 示例4：两个完全独立的切片
    sliceG := make([]byte, 5)
    sliceH := make([]byte, 5)
    fmt.Printf("sliceG 的起始地址: %v\n", reflect.ValueOf(sliceG).Pointer())
    fmt.Printf("sliceH 的起始地址: %v\n", reflect.ValueOf(sliceH).Pointer())
    fmt.Printf("sliceG 和 sliceH 是否引用同一内存起始地址? %t\n", 
               reflect.ValueOf(sliceG).Pointer() == reflect.ValueOf(sliceH).Pointer())
    // 预期输出：false
}