Go中如何计算结构体实例含指向对象的总内存占用？

嘿，这个问题问到点子上了——Go 里的 unsafe.Sizeof() 确实只会计算结构体本身的直接内存大小，完全不会递归统计它引用的对象（比如指针指向的结构体、切片底层数组这些）。针对你提到的两个场景，我给你梳理下实用的解决方案：

你说得没错，unsafe.Sizeof(*bigInt) 返回的16字节只是 big.Int 结构体本身的大小（里面存了指针、长度这些元数据），真正的数值存储在它内部的切片里。

要统计它的真实内存，最安全的方式是利用 big.Int 提供的导出方法 Bits()，它会返回一个存储数值二进制位的 []uint 切片。我们只需要把结构体本身的大小，加上这个切片底层数组的内存大小即可：

import (
    "math/big"
    "unsafe"
)

func GetBigIntTotalSize(bi *big.Int) uintptr {
    // 先算 big.Int 结构体本身的大小
    total := unsafe.Sizeof(*bi)
    // 获取存储数值的切片
    bits := bi.Bits()
    if bits != nil {
        // 加上切片底层数组的内存（每个元素的大小 * 元素数量）
        total += unsafe.Sizeof(bits[0]) * uintptr(len(bits))
    }
    return total
}

为啥用 Bits() 而不是直接访问 big.Int 的未导出字段？因为Go版本更新可能会修改内部结构，用导出方法能保证兼容性，不会因为版本升级导致代码失效。

这种场景更复杂，核心难点是处理循环引用（比如环形链表），不然递归统计会陷入死循环。我们需要实现一个深度遍历函数，同时记录已经统计过的对象地址，避免重复计算。

这里用反射来遍历各种类型（结构体、指针、切片、map等），递归累加所有可达对象的内存大小：

import (
    "reflect"
    "unsafe"
)

// DeepSize 计算任意值的总内存占用，包括所有引用的对象
func DeepSize(v interface{}) uintptr {
    // 用 map 记录已经访问过的对象地址，避免循环引用重复统计
    visited := make(map[uintptr]bool)
    var calculateSize func(reflect.Value) uintptr

    calculateSize = func(val reflect.Value) uintptr {
        // 无效值直接返回0
        if !val.IsValid() {
            return 0
        }

        // 处理指针和接口类型：先解引用，同时检查是否已经访问过
        for val.Kind() == reflect.Ptr || val.Kind() == reflect.Interface {
            if val.IsNil() {
                return 0
            }
            addr := val.UnsafePointer()
            if visited[addr] {
                return 0 // 已经统计过，跳过
            }
            visited[addr] = true
            val = val.Elem()
        }

        // 先计算当前值本身的大小
        total := unsafe.Sizeof(val.Interface())

        // 根据类型递归处理内部元素
        switch val.Kind() {
        case reflect.Struct:
            // 遍历结构体的每个字段，累加大小
            for i := 0; i < val.NumField(); i++ {
                total += calculateSize(val.Field(i))
            }
        case reflect.Slice:
            // 切片本身的大小已经算过，现在加底层数组的大小，再递归处理每个元素
            if val.Len() > 0 {
                elemSize := unsafe.Sizeof(val.Index(0).Interface())
                total += elemSize * uintptr(val.Len())
                for i := 0; i < val.Len(); i++ {
                    total += calculateSize(val.Index(i))
                }
            }
        case reflect.Map:
            // 遍历map的所有键值对，累加它们的大小
            iter := val.MapRange()
            for iter.Next() {
                total += calculateSize(iter.Key())
                total += calculateSize(iter.Value())
            }
        case reflect.Array:
            // 遍历数组每个元素，累加大小
            for i := 0; i < val.Len(); i++ {
                total += calculateSize(val.Index(i))
            }
        }
        return total
    }

    return calculateSize(reflect.ValueOf(v))
}

举个链表的例子，假设你的链表节点结构体是这样的：

type ListNode struct {
    Val  int
    Next *ListNode
}

用 DeepSize(head) 就能统计整个链表的总内存，包括所有节点的Val和Next指针指向的后续节点，就算是环形链表也不会死循环——因为第一次访问节点时会记录它的地址，后续再遇到就直接跳过。

不过要注意，这个方法不是万能的：

• 无法统计Go runtime内部的额外开销（比如map的哈希表底层结构、操作系统的内存页对齐开销），但对于业务上的内存估算已经足够准确。
• 对于一些内部结构复杂的标准库类型（比如sync.Map），可能统计不完全，但自定义结构体、链表这类场景完全适用。

内容的提问来源于stack exchange，提问作者user40176