如何准确计算 Go 语言切片（Slice）内容的字节大小

array := [...]float32{1.0, 2.0, 3.0}
array_size := gl.Sizeiptr(unsafe.Sizeof(array)) // 获取整个数组的字节大小

slice := []int64{1, 2, 3}
size := uintptr(len(slice)) * unsafe.Sizeof(slice[0])

uintptr(len(s)) * reflect.TypeOf(s).Elem().Size()

package main

import (
    "fmt"
    "reflect"
    "unsafe" // 用于对比 unsafe.Sizeof 的结果
)

// GetSliceContentByteSize 计算切片或数组内容的字节大小。
// s 必须是一个切片或数组类型（例如 []int, [5]byte），不能是 nil 接口值。
func GetSliceContentByteSize(s interface{}) uintptr {
    // 如果 s 是一个 nil 接口值 (interface{}(nil))，直接返回 0。
    // 注意：如果 s 是一个类型为 []int 但值为 nil 的切片 (var mySlice []int)，
    // reflect.TypeOf(mySlice) 仍然能获取到 []int 类型，此时 len(mySlice) 为 0，
    // 结果依然是 0，因此不需要特殊处理。
    if s == nil {
        return 0
    }

    // 获取 s 的反射类型
    t := reflect.TypeOf(s)

    // 检查 s 是否是切片或数组类型
    kind := t.Kind()
    if kind != reflect.Slice && kind != reflect.Array {
        fmt.Printf("警告: GetSliceContentByteSize 期望切片或数组类型，但接收到 %s (%T)\n", kind, s)
        return 0 // 或者根据需求返回错误
    }

    // 获取切片或数组的长度
    v := reflect.ValueOf(s)
    length := v.Len()

    // 如果长度为0，则内容大小为0
    if length == 0 {
        return 0
    }

    // 获取元素类型并计算其大小
    elemType := t.Elem() // 对于切片或数组，Elem() 返回其元素类型
    elemSize := elemType.Size()

    return uintptr(length) * elemSize
}

func main() {
    fmt.Println("--- 数组示例 ---")
    // 示例 1: 数组 ([5]int8)
    a := [...]int8{2, 3, 5, 7, 11} // 5个 int8 元素
    fmt.Printf("数组 a (%T): 长度=%d, 元素大小=%d, 内容字节大小=%d\n",
        a, len(a), unsafe.Sizeof(a[0]), GetSliceContentByteSize(a))
    // 预期输出: 数组 a ([5]int8): 长度=5, 元素大小=1, 内容字节大小=5

    fmt.Println("\n--- 切片示例 ---")
    // 示例 2: 非空切片 ([]int64)
    s := []int64{2, 3, 5, 7, 11} // 5个 int64 元素
    fmt.Printf("切片 s (%T): 长度=%d, 元素大小=%d, 内容字节大小=%d\n",
        s, len(s), unsafe.Sizeof(s[0]), GetSliceContentByteSize(s))
    // 预期输出: 切片 s ([]int64): 长度=5, 元素大小=8, 内容字节大小=40

    // 示例 3: 空切片 ([]int32)
    z := []int32{} // 0个 int32 元素
    // 注意：unsafe.Sizeof(z[0]) 会引发 panic，这里使用 reflect.TypeOf(z).Elem().Size() 安全获取元素大小
    fmt.Printf("切片 z (%T): 长度=%d, 元素大小=%d, 内容字节大小=%d\n",
        z, len(z), reflect.TypeOf(z).Elem().Size(), GetSliceContentByteSize(z))
    // 预期输出: 切片 z ([]int32): 长度=0, 元素大小=4, 内容字节大小=0

    // 示例 4: nil 切片 (已声明类型)
    var nilSlice []float32 // 0个 float32 元素
    fmt.Printf("nil 切片 (%T): 长度=%d, 元素大小=%d, 内容字节大小=%d\n",
        nilSlice, len(nilSlice), reflect.TypeOf(nilSlice).Elem().Size(), GetSliceContentByteSize(nilSlice))
    // 预期输出: nil 切片 ([]float32): 长度=0, 元素大小=4, 内容字节大小=0

    // 示例 5: 其他类型（错误处理演示）
    var i int = 10
    fmt.Printf("非切片/数组类型 i (%T): 内容字节大小=%d\n", i, GetSliceContentByteSize(i))
    // 预期输出: 警告: GetSliceContentByteSize 期望切片或数组类型，但接收到 int (int)
    //          非切片/数组类型 i (int): 内容字节大小=0

    // 示例 6: 结构体切片
    type MyStruct struct {
        X int32
        Y float64
    }
    structSlice := []MyStruct{{X: 1, Y: 1.1}, {X: 2, Y: 2.2}}
    fmt.Printf("结构体切片 (%T): 长度=%d, 元素大小=%d, 内容字节大小=%d\n",
        structSlice, len(structSlice), reflect.TypeOf(structSlice).Elem().Size(), GetSliceContentByteSize(structSlice))
    // 预期输出: 结构体切片 ([]main.MyStruct): 长度=2, 元素大小=16 (或根据对齐规则有所不同), 内容字节大小=32
    // (MyStruct: int32(4字节) + float64(8字节) = 12字节，但由于内存对齐，可能为16字节)
}