Go语言中获取切片内容字节大小的通用方法

array := [...]int32{1, 2, 3, 4, 5}
array_size := unsafe.Sizeof(array) // 获取整个数组的字节大小
// 或者 array_size := uintptr(len(array)) * unsafe.Sizeof(array[0])

slice := []int64{10, 20, 30}
// 假设 slice 非空，且所有元素类型相同
size := uintptr(len(slice)) * unsafe.Sizeof(slice[0])

package main

import (
    "fmt"
    "reflect"
    "unsafe" // 仅用于对比，实际计算切片内容大小不推荐直接使用 unsafe.Sizeof(slice[0])
)

// GetSliceContentSizeBytes 计算切片内容的总字节大小
// 它能安全地处理空切片，并自动识别元素类型。
func GetSliceContentSizeBytes(s interface{}) uintptr {
    // 确保输入是一个切片类型
    val := reflect.ValueOf(s)
    if val.Kind() != reflect.Slice {
        // 如果不是切片，可以根据需求返回错误或0
        fmt.Printf("警告: 输入的不是切片类型 (%T)，返回 0 字节。\n", s)
        return 0
    }

    // 获取切片元素的类型信息
    elemType := reflect.TypeOf(s).Elem()

    // 获取单个元素的字节大小
    elemSize := elemType.Size() // reflect.Type.Size() 返回类型在内存中占用的字节数

    // 获取切片的长度
    sliceLen := uintptr(val.Len())

    // 计算总字节大小
    return sliceLen * elemSize
}

func main() {
    // 示例1: 整型切片
    s1 := []int64{2, 3, 5, 7, 11}
    size1 := GetSliceContentSizeBytes(s1)
    fmt.Printf("切片 s1 (%T, len=%d) 的内容字节大小: %d 字节\n", s1, len(s1), size1)
    // 验证：5个int64，每个8字节，总计 5 * 8 = 40 字节
    fmt.Printf("验证 s1: len=%d, elemSize=%d, total=%d\n", len(s1), reflect.TypeOf(s1).Elem().Size(), uintptr(len(s1)) * reflect.TypeOf(s1).Elem().Size())


    // 示例2: 浮点型切片
    s2 := []float32{1.1, 2.2, 3.3}
    size2 := GetSliceContentSizeBytes(s2)
    fmt.Printf("切片 s2 (%T, len=%d) 的内容字节大小: %d 字节\n", s2, len(s2), size2)
    // 验证：3个float32，每个4字节，总计 3 * 4 = 12 字节
    fmt.Printf("验证 s2: len=%d, elemSize=%d, total=%d\n", len(s2), reflect.TypeOf(s2).Elem().Size(), uintptr(len(s2)) * reflect.TypeOf(s2).Elem().Size())


    // 示例3: 空切片
    s3 := []int32{}
    size3 := GetSliceContentSizeBytes(s3)
    fmt.Printf("切片 s3 (%T, len=%d) 的内容字节大小: %d 字节\n", s3, len(s3), size3)
    // 验证：0个int32，每个4字节，总计 0 * 4 = 0 字节
    fmt.Printf("验证 s3: len=%d, elemSize=%d, total=%d\n", len(s3), reflect.TypeOf(s3).Elem().Size(), uintptr(len(s3)) * reflect.TypeOf(s3).Elem().Size())


    // 示例4: 包含结构体的切片
    type Point struct {
        X, Y int16
    }
    s4 := []Point{{1, 2}, {3, 4}}
    size4 := GetSliceContentSizeBytes(s4)
    fmt.Printf("切片 s4 (%T, len=%d) 的内容字节大小: %d 字节\n", s4, len(s4), size4)
    // 验证：2个Point，每个Point包含两个int16（2*2=4字节），总计 2 * 4 = 8 字节
    fmt.Printf("验证 s4: len=%d, elemSize=%d, total=%d\n", len(s4), reflect.TypeOf(s4).Elem().Size(), uintptr(len(s4)) * reflect.TypeOf(s4).Elem().Size())

    // 示例5: 数组（为演示通用性，但主要针对切片）
    a1 := [...]int8{1, 2, 3, 4, 5}
    // 注意：GetSliceContentSizeBytes 明确检查了类型，因此传入数组会报错
    // 如果需要处理数组，函数内部需要修改逻辑
    sizeA1 := GetSliceContentSizeBytes(a1) // 会输出警告
    fmt.Printf("数组 a1 (%T) 的内容字节大小: %d 字节\n", a1, sizeA1)

    // 演示 unsafe.Sizeof(array) 与 GetSliceContentSizeBytes 的区别
    fmt.Printf("数组 a1 实际总字节大小 (unsafe.Sizeof): %d 字节\n", unsafe.Sizeof(a1))
}