Go语言中切片内容字节大小的精确计算方法

s := []int64{2, 3, 5, 7, 11}
// 计算内容字节大小的初步尝试
size := uintptr(len(s)) * unsafe.Sizeof(s[0])
fmt.Println("初步计算的切片内容大小:", size, "字节") // 输出: 40 字节 (5 * 8)

totalBytes := uintptr(len(s)) * reflect.TypeOf(s).Elem().Size()

package main

import (
    "fmt"
    "reflect"
    "unsafe" // 仅用于对比 unsafe.Sizeof

)

// GetSliceContentSizeBytes 计算切片内容的总字节数
// s: 任意类型的切片
// 返回值: 切片内容的总字节数
func GetSliceContentSizeBytes(s interface{}) (uintptr, error) {
    // 检查输入是否为切片类型
    val := reflect.ValueOf(s)
    if val.Kind() != reflect.Slice {
        return 0, fmt.Errorf("输入必须是切片类型，当前为: %s", val.Kind())
    }

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

    // 获取切片元素的类型
    elemType := val.Type().Elem()

    // 获取单个元素的大小
    elemSize := elemType.Size()

    // 计算总字节数
    return uintptr(sliceLen) * elemSize, nil
}

func main() {
    // 示例1: 非空 []int8 切片
    a := []int8{2, 3, 5, 7, 11}
    sizeA, errA := GetSliceContentSizeBytes(a)
    if errA != nil {
        fmt.Println("Error:", errA)
    } else {
        fmt.Printf("切片 a ([]int8): 长度 %d, 元素大小 %d 字节, 内容总大小 %d 字节\n", len(a), reflect.TypeOf(a).Elem().Size(), sizeA)
        // 对比 unsafe.Sizeof: uintptr(len(a)) * unsafe.Sizeof(a[0]) -> 5 * 1 = 5
        fmt.Printf("  (unsafe.Sizeof对比: %d 字节)\n", uintptr(len(a)) * unsafe.Sizeof(a[0]))
    }

    // 示例2: 非空 []int64 切片
    s := []int64{2, 3, 5, 7, 11}
    sizeS, errS := GetSliceContentSizeBytes(s)
    if errS != nil {
        fmt.Println("Error:", errS)
    } else {
        fmt.Printf("切片 s ([]int64): 长度 %d, 元素大小 %d 字节, 内容总大小 %d 字节\n", len(s), reflect.TypeOf(s).Elem().Size(), sizeS)
        // 对比 unsafe.Sizeof: uintptr(len(s)) * unsafe.Sizeof(s[0]) -> 5 * 8 = 40
        fmt.Printf("  (unsafe.Sizeof对比: %d 字节)\n", uintptr(len(s)) * unsafe.Sizeof(s[0]))
    }

    // 示例3: 空 []int32 切片
    z := []int32{}
    sizeZ, errZ := GetSliceContentSizeBytes(z)
    if errZ != nil {
        fmt.Println("Error:", errZ)
    } else {
        fmt.Printf("切片 z ([]int32): 长度 %d, 元素大小 %d 字节, 内容总大小 %d 字节\n", len(z), reflect.TypeOf(z).Elem().Size(), sizeZ)
        // 注意：此处如果使用 unsafe.Sizeof(z[0]) 会导致 panic
    }

    // 示例4: 自定义结构体切片
    type MyStruct struct {
        ID   int32
        Name [4]byte // 假设名字固定4字节
    }
    ms := []MyStruct{
        {ID: 1, Name: [4]byte{'t', 'e', 's', 't'}},
        {ID: 2, Name: [4]byte{'d', 'a', 't', 'a'}},
    }
    sizeMS, errMS := GetSliceContentSizeBytes(ms)
    if errMS != nil {
        fmt.Println("Error:", errMS)
    } else {
        fmt.Printf("切片 ms ([]MyStruct): 长度 %d, 元素大小 %d 字节, 内容总大小 %d 字节\n", len(ms), reflect.TypeOf(ms).Elem().Size(), sizeMS)
        // MyStruct 的大小通常是 int32(4字节) + [4]byte(4字节) = 8字节
        // 2 * 8 = 16 字节
    }

    // 示例5: 非切片类型输入
    notSlice := "hello"
    sizeNS, errNS := GetSliceContentSizeBytes(notSlice)
    if errNS != nil {
        fmt.Println("Error:", errNS) // 预期输出错误信息
    } else {
        fmt.Printf("非切片类型输入: 内容总大小 %d 字节\n", sizeNS)
    }
}

切片 a ([]int8): 长度 5, 元素大小 1 字节, 内容总大小 5 字节
  (unsafe.Sizeof对比: 5 字节)
切片 s ([]int64): 长度 5, 元素大小 8 字节, 内容总大小 40 字节
  (unsafe.Sizeof对比: 40 字节)
切片 z ([]int32): 长度 0, 元素大小 4 字节, 内容总大小 0 字节
切片 ms ([]MyStruct): 长度 2, 元素大小 8 字节, 内容总大小 16 字节
Error: 输入必须是切片类型，当前为: string