unsafe.sizeof()

描述

// Sizeof takes an expression x of any type and returns the size in bytes
// of a hypothetical variable v as if v was declared via var v = x.
// The size does not include any memory possibly referenced by x.
// For instance, if x is a slice,  Sizeof returns the size of the slice
// descriptor, not the size of the memory referenced by the slice.
func Sizeof(x ArbitraryType) uintptr

翻译：
//size of接受任何类型的表达式x并返回一个假设变量v的字节大小，就好像v是通过var v=x声明的。
//该大小不包括X可能引用的任何内存
//例如，如果x是一个切片，size of返回切片描述符的大小，而不是切片引用的内存大小

测试

package main

import (
	"fmt"
	"unsafe"
)

type iface interface {
	D()
}

type Man struct {
	Name string
	Age int  //大小和机器位数有关
}

type Woman struct {
}


func main() {
	// 字符串
	str1 := "abc"
	fmt.Println("string1:", unsafe.Sizeof(str1)) // 16
	str2 := "abcdef"
	fmt.Println("string2:", unsafe.Sizeof(str2)) // 16

	// 数组
	arr1 := [...]int{1, 2, 3, 4}
	fmt.Println("array1:", unsafe.Sizeof(arr1)) // 32 = 8 * 4

	arr2 := [...]int{1, 2, 3, 4, 5}
	fmt.Println("array2:", unsafe.Sizeof(arr2)) // 40 = 8 * 5

	// 切片
	slice1 := []int{1, 2, 3, 4}
	fmt.Println("slice1:", unsafe.Sizeof(slice1)) // 24

	slice2 := []int{1, 2, 3, 4, 5}
	fmt.Println("slice2:", unsafe.Sizeof(slice2)) // 24

	slice3 := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
	fmt.Println("slice3:", unsafe.Sizeof(slice3)) // 24

	// 接口、空接口
	var interface1 interface{}
	fmt.Println("interface1:", unsafe.Sizeof(interface1)) //16

	var interface2 iface
	fmt.Println("interface2:", unsafe.Sizeof(interface2)) //16

	// 结构体、空结构体
	st1 := Man{}
	fmt.Println("struct1:", unsafe.Sizeof(st1)) //32
	fmt.Println("struct1.Name:", unsafe.Sizeof(st1.Name)) //16
	fmt.Println("struct1.Age:", unsafe.Sizeof(st1.Age)) //8

	st2 := Woman{}
	fmt.Println("struct2:", unsafe.Sizeof(st2)) //0
   
    //映射
	m1 := map[string]int{
		"h":1,
		"e":2,
		"l":3,
		"o":4,
	}
	fmt.Println("map1:", unsafe.Sizeof(m1)) //8

	m2 := map[string]int{}
	fmt.Println("map2:", unsafe.Sizeof(m2)) //8
  
   # 指针
   var i = 8
   var ip = &i
   var s = "sss"
   var sp = &s
   var f = 9.99
   var fp = &f
   fmt.Println("pointer1：", unsafe.Sizeof(ip)) //8
   fmt.Println("pointer2：", unsafe.Sizeof(sp)) //8
   fmt.Println("pointer3:", unsafe.Sizeof(fp)) //8
}

分析

• 为什么字符串类型的 unsafe.Sizeof() 一直是16呢？
  实际上字符串类型对应一个结构体，该结构体有两个域，第一个域是指向该字符串的指针，第二个域是字符串的长度，每个域占8个字节，但是并不包含指针指向的字符串的内容，这也就是为什么sizeof始终返回的是16。
• 编译的时候系统自动分配内存，int的长度是由系统平台来决定的，我用的是64位的系统，所以一个int 代表的就是 int64 数据类型，每个数字占用8个字节。byte(1字节)，uint8(1字节)，uint16(2字节)，uint32(4字节)，uint64(占用8字节), byte是uint8的别名，这些全是无符号型的，对应的还有有符号型的，区别也就是一个值范围不同而已。
• 不同数据类型，其底层结构不一样
• 具体查看golang底层数据类型实现原理