应该从变量说起

//var 变量名 变量类型

变量名是内存地址的别名, 起名要避讳关键字.

变量类型:
1.内容编址模型; 内存中只能存放01
2.数值型: 如果是无符号数,使用源码存放; 如果是有符号数, 使用补码存放.
  字符型: 会通过ascii表映射为01存储.
3.不同类型, 占用内存大小不一样. int占4byte,

4.go支持强制类型转换, 但是没有隐式类型转换.

下面是c语言中内存, 如果在栈上连续开辟, c中可以看到地址连续变小. 如果在堆上开辟内存, 可以看到内存地址变大.

字长屏蔽了操作系统bit,使代码支持跨平台

func main() {
	var a int = 10
	fmt.Println(unsafe.Sizeof(a)) //8
}

字长和操作系统位数有关.

字长：CPU一次操作可以处理的二进制比特数(0或1), 1字长 = 1 bit

    一个字长是8的cpu，  一次能进行不大于 1111,1111 (8位) 的运算
    一个字长是16的cpu ，一次能进行不大于 1111,1111,1111,1111(16位)的运算

//整型

// wordSize代表是一个word里包含多少字节
// 64bit: 8 bytes
// 32bit: 4 bytes


// The word size is the number of bytes in a word, which matches our address size.
// For example, in 64-bit architecture, the word size is 64 bit (8 bytes), address size is 64
// bit then our integer should be 64 bit.

//字符串

// Strings are a series of uint8 types.
// A string is a two word data structure: first word represents a pointer to a backing array, the
// second word represents its length.

// If it is a zero value then the first word is nil, the second word is 0.

//字符串是2个wordSize的数据结构
type stringStruct struct {
	str unsafe.Pointer
	len int
}



type slice struct {
	array unsafe.Pointer
	len   int
	cap   int
}


type hmap struct {
	// Note: the format of the hmap is also encoded in cmd/compile/internal/gc/reflect.go.
	// Make sure this stays in sync with the compiler's definition.
	count     int // # live cells == size of map.  Must be first (used by len() builtin)
	flags     uint8
	B         uint8  // log_2 of # of buckets (can hold up to loadFactor * 2^B items)
	noverflow uint16 // approximate number of overflow buckets; see incrnoverflow for details
	hash0     uint32 // hash seed

	buckets    unsafe.Pointer // array of 2^B Buckets. may be nil if count==0.
	oldbuckets unsafe.Pointer // previous bucket array of half the size, non-nil only when growing
	nevacuate  uintptr        // progress counter for evacuation (buckets less than this have been evacuated)

	extra *mapextra // optional fields
}

在 Go 中，指针就是 uintptr 类型。同样地，基于操作系统的体系结构，它将映射为 uint32 或者 uint64。
Go 为指针创建了一个特殊的类型。

//x 表示占位符, 1个字节

struct {byte,int32,int64} //16
bxxx|iiii|jjjj|jjjj

struct {byte,int64,int32} //24
bxxx|xxxx|jjjj|jjjj|iiii|xxxx


struct {int32,byte,int64} //16
iiii|bxxx|jjjj|jjjj

struct {int32,int64,byte} //24
iiii|xxxx|jjjj|jjjj|bxxx|xxxx


struct {int64,byte,int32} //16
jjjj|jjjj|bxxx|iiii

struct {int64,int32,byte} //16
jjjj|jjjj|iiii|bxxx

//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. 
The return value of Sizeof is a Go constant.

//如果x为一个切片，sizeof返回的大小是切片的描述符(该type在内存中开辟了多大空间)，而不是切片所指向的内存的大小。
if x is a slice, Sizeof returns the size of the slice descriptor, not the size of the memory referenced by the slice.

参考
unsafe，顾名思义，是不安全的. 但是它也有它的优势，那就是可以绕过Go的内存安全机制，直接对内存进行读写，所以有时候因为性能的需要，会冒一些风险使用该包，对内存进行操作。

Sizeof函数: Sizeof到底量的是什么的尺寸?

Sizeof函数可以返回一个类型所占用的内存大小

这个大小只与类型有关，和类型对应的变量存储的内容大小无关，比如bool型占用一个字节、int8也占用一个字节。

func main() {
    fmt.Println(unsafe.Sizeof(true))                  //1
    fmt.Println(unsafe.Sizeof(int8(0)))    			  //1
    fmt.Println(unsafe.Sizeof(int16(10))) 			  //2
    fmt.Println(unsafe.Sizeof(int32(10000000)))		  //4
    fmt.Println(unsafe.Sizeof(int64(10000000000000))) //8
    fmt.Println(unsafe.Sizeof(int(10000000000000000)))//8
}

对于整型来说，占用的字节数意味着这个类型存储数字范围的大小，

    比如int8占用一个字节，也就是8bit，所以它可以存储的大小范围是-128~~127,
    也就是−2^(n-1)到2^(n-1)−1，n表示bit，int8表示8bit，int16表示16bit，其他以此类推。

对于和平台有关的int类型，这个要看平台是32位还是64位，会取最大的。

比如我自己测试，以上输出，会发现int和int64的大小是一样的，因为我的是64位平台的电脑。

func Sizeof(x ArbitraryType) uintptr

以上是Sizeof的函数定义，它接收一个ArbitraryType类型的参数，返回一个uintptr类型的值。

这里的ArbitraryType不用关心，他只是一个占位符，为了文档的考虑导出了该类型，但是一般不会使用它，
我们只需要知道它表示任何类型，也就是我们这个函数可以接收任意类型的数据。

// ArbitraryType is here for the purposes of documentation only and is not actually
// part of the unsafe package. It represents the type of an arbitrary Go expression.
type ArbitraryType int

struct大小

我们定义一个struct，这个struct有3个字段，它们的类型有byte,int32以及int64,但是这三个字段的顺序我们可以任意排列，那么根据顺序的不同，一共有6种组合。

type user1 struct {
	b byte
	i int32
	j int64
}

type user2 struct {
	b byte
	j int64
	i int32
}

type user3 struct {
	i int32
	b byte
	j int64
}

type user4 struct {
	i int32
	j int64
	b byte
}

type user5 struct {
	j int64
	b byte
	i int32
}

type user6 struct {
	j int64
	i int32
	b byte
}

根据这6种组合，定义了6个struct，分别位user1，user2，…，user6，那么现在大家猜测一下，这6种类型的struct占用的内存是多少，就是unsafe.Sizeof()的值。

大家可能猜测1+4+8=13，因为byte的大小为1，int32大小为4，int64大小为8，而struct其实就是一个字段的组合，所以猜测struct大小为字段大小之和也很正常。

但是，但是，我可以明确的说，这是错误的。

为什么是错误的，因为有内存对齐存在，编译器使用了内存对齐，那么最后的大小结果就不一样了。现在我们正式验证下，这几种struct的值。

func main() {
	var u1 user1
	var u2 user2
	var u3 user3
	var u4 user4
	var u5 user5
	var u6 user6

	fmt.Println("u1 size is ",unsafe.Sizeof(u1)) //16
	fmt.Println("u2 size is ",unsafe.Sizeof(u2)) //24
	fmt.Println("u3 size is ",unsafe.Sizeof(u3)) //16 
	fmt.Println("u4 size is ",unsafe.Sizeof(u4)) //24
	fmt.Println("u5 size is ",unsafe.Sizeof(u5)) //16
	fmt.Println("u6 size is ",unsafe.Sizeof(u6)) //16
}

结果出来了（我的电脑的结果，Mac64位，你的可能不一样），4个16字节，2个24字节，既不一样，又不相同，这说明：

内存对齐影响struct的大小
struct的字段顺序影响struct的大小

综合以上两点，我们可以得知，不同的字段顺序，最终决定struct的内存大小，所以有时候合理的字段顺序可以减少内存的开销。

内存对齐会影响struct的内存占用大小，现在我们就详细分析下，为什么字段定义的顺序不同会导致struct的内存占用不一样。

在分析之前，我们先看下内存对齐的规则：

1. 对于具体类型来说，
    对齐值=min(编译器默认对齐值，类型大小Sizeof长度)。
    
    也就是在默认设置的对齐值和类型的内存占用大小之间，取最小值为该类型的对齐值。
    我的电脑默认是8，所以最大值不会超过8.

2. struct在每个字段都内存对齐之后，其本身也要进行对齐，
    对齐值=min(默认对齐值，字段最大类型长度)。
    
    这条也很好理解，struct的所有字段中，最大的那个类型的长度以及默认对齐值之间，取最小的那个。

以上这两条规则要好好理解，理解明白了才可以分析下面的struct结构体。在这里再次提醒，对齐值也叫对齐系数、对齐倍数，对齐模数。

这就是说，每个字段在内存中的偏移量是对齐值的倍数即可。

我们知道byte，int32，int64的对齐值分别为1，4，8，占用内存大小也是1，4，8。那么对于第一个structuser1，它的字段顺序是byte、int32、int64，我们先使用第1条内存对齐规则进行内存对齐，其内存结构如下。

//x 表示占位符, 1个字节
bxxx|iiii|jjjj|jjjj

user1类型，

第1个字段byte，对齐值1，大小1，所以放在内存布局中的第1位。

第2个字段int32，对齐值4，大小4，所以它的内存偏移值必须是4的倍数，在当前的user1中，就不能从第2位开始了，必须从第5位开始，也就是偏移量为4。第2，3，4位由编译器进行填充，一般为值0，也称之为内存空洞。所以第5位到第8位为第2个字段i。

第3字段，对齐值为8，大小也是8。因为user1前两个字段已经排到了第8位，所以下一位的偏移量正好是8，是第3个字段对齐值的倍数，不用填充，可以直接排列第3个字段，也就是从第9位到第16位为第3个字段j。

现在第一条内存对齐规则后，内存长度已经为16个字节，我们开始使用内存的第2条规则进行对齐。

根据第二条规则，

默认对齐值8，字段中最大类型长度也是8，所以求出结构体的对齐值位8，我们目前的内存长度为16，是8的倍数，已经实现了对齐。

所以到此为止，结构体user1的内存占用大小为16字节。

现在我们再分析一个user2类型，它的大小是24，只是调换了一下字段i和j的顺序，就多占用了8个字节，我们看看为什么？还是先使用我们的内存第1条规则分析。

bxxx|xxxx|jjjj|jjjj|iiii

按对齐值和其占用的大小，第1个字段b偏移量为0，占用1个字节，放在第1位。

第2个字段j，是int64，对齐值和大小都是8，所以要从偏移量8开始，也就是第9到16位为j，这也就意味着第2到8位被编译器填充。

目前整个内存布局已经偏移了16位，正好是第3个字段i的对齐值4的倍数，所以不用填充，可以直接排列，第17到20位为i。

现在所有字段对齐好了，整个内存大小为1+7+8+4=20个字节，我们开始使用内存对齐的第2条规则，也就是结构体的对齐，通过默认对齐值和最大的字段大小，求出结构体的对齐值为8。

现在我们的整个内存布局大小为20，不是8的倍数，所以我们需要进行内存填充，补足到8的倍数，最小的就是24，所以对齐后整个内存布局为

bxxx|xxxx|jjjj|jjjj|iiii|xxxx

所以这也是为什么我们最终获得的user2的大小为24的原因。 基于以上办法，我们可以得出其他几个struct的内存布局。

user3

iiii|bxxx|jjjj|jjjj

user4

iiii|xxxx|jjjj|jjjj|bxxx|xxxx

user5

jjjj|jjjj|bxxx|iiii

user6

jjjj|jjjj|iiii|bxxx

以上给出了答案，推到过程大家可以参考user1和user2试试。下一篇我们介绍通过unsafe.Pointer进行内存的运算，以及对内存的读写。