golang 底层

1、数据类型底层
（一）string
string类型的底层是一个C struct

           struct String{
                   byte* str;
                   intgo len;
               }

成员str为字符数组，len为字符数组长度。golang的字符串是不可以变类型，对string类型的变量初始化意味着对底层结构的初始化。为什么str用byte类型不用rune类型，因为golang的for循环对字符串的遍历是基于字节的，如果有必要，可以转rune切片或者用range来迭代。

    package main

import (
    "fmt"
    "unsafe"
)

func main() {
    var str string = "hi, 张三丰~"
    p := (*struct {
        str uintptr
        len int
    })(unsafe.Pointer(&str))

    fmt.Printf("%+v\n", p)
}

运行:

    >  go run dataType.go
    >  &{str:17591088 len:14}

内建函数len对string类型的操作是直接从底层结构中取出len值，不需要额外的操作，在初始化时必须同时初始化len的值

（二）Slice类型
slice底层也是一个C struct

      struct slice{
                 byte* arrary; //actutal data
                 uintgo len; //number of elements
                 uintgo cap;// allocated number of elements
           };

包括三个成员：
arrary ——— 为底层数组
len —— — 为实际存放的个数
cap ——— 为存放容量
使用内建函数make对slice初始化，也可以类似数组的方式进行初始化，当使用make函数对slice进行初始化时，第一个参数为切片类型，第二个参 数为len，第三个参数可选，如果不输入，怎cap等于len。

通常出入cap参数来预先分配大小的slice，避免频繁重新分配内存。

     package main

import (
      "fmt"
      "unsafe"
)

func main() {
      /*string*/
      var str string = "hi, 张三丰~"
      p := (*struct {
            str uintptr
            len int
      })(unsafe.Pointer(&str))
      fmt.Printf("%+v\n", p)

      /*slice*/
      var slice []int32 = make([]int32, 5, 10)
      p1 := (*struct {
            arrary uintptr
            len int
            cap int
      })(unsafe.Pointer(&slice))

      fmt.Printf("%+v\n", p1)
}

运行:

    > go run demo.go
       &{str:17591536 len:14}
       &{arrary:842350559424 len:5 cap:10}

由于切片只想一个底层数组，并且可以通过切片语法直接从数组生成切片，所以了解slice和数组的区别和关系，否则在编程过程中写出bug代码。

     package main

import (
      "fmt"
      "unsafe"
)

func main() {
      /*string*/
      var str string = "hi, 张三丰~"
      p := (*struct {
            str uintptr
            len int
      })(unsafe.Pointer(&str))
      fmt.Printf("%+v\n", p)

      /*slice*/
      var slice []int32 = make([]int32, 5, 10)
      p1 := (*struct {
            arrary uintptr
            len int
            cap int
      })(unsafe.Pointer(&slice))

      fmt.Printf("%+v\n", p1)

      var arrary = [...]int32{1, 2, 3, 4, 5, 6, 7}
      var slices = arrary[2:5]

      fmt.Printf("改变slice之前: array=%+v, slice=%+v\n", arrary, slices)
      slices[0] = 234

      fmt.Printf("改变slice之后: array=%+v, slice=%+v\n", arrary, slices)
}

运行：

>  go run dataType.go
    &{str:17592528 len:14}
    &{arrary:842350559424 len:5 cap:10}
改变slice之前: array=[1 2 3 4 5 6 7], slice=[3 4 5]
改变slice之后: array=[1 2 234 4 5 6 7], slice=[234 4 5]

您可以清楚的看到，在改变slice后，array也被改变了。这是因为slice通过数组创建的切片指向这个数组，也就是说这个slice的底层数组就是这个array。因此很显然，slice的改变其实就是改变它的底层数组。当然如果删除或添加元素，那么len也会变化，cap可能会变化。

那这个slice是如何指向array呢？slice的底层数组指针指向array中索引为2的元素(因为切片是通过array[2:4]来生成的)，len记录元素个数，而cap则等于len。

之所以说cap可能会变，是因为cap表示总容量，添加或删除操作不一定会使总容量发生变化。我们接着再来看另一个例子：

      package main

import (
      "fmt"
      "unsafe"
)

func main() {
      /*string*/
      var str string = "hi, 张三丰~"
      p := (*struct {
            str uintptr
            len int
      })(unsafe.Pointer(&str))
      fmt.Printf("%+v\n", p)

      /*slice*/
      var slice []int32 = make([]int32, 5, 10)
      p1 := (*struct {
            arrary uintptr
            len int
            cap int
      })(unsafe.Pointer(&slice))

      fmt.Printf("%+v\n", p1)

      var arrary = [...]int32{1, 2, 3, 4, 5, 6, 7}
      var slices = arrary[2:5]

      fmt.Printf("改变slice之前: array=%+v, slice=%+v\n", arrary, slices)
      slices[0] = 234

      fmt.Printf("改变slice之后: array=%+v, slice=%+v\n", arrary, slices)

      /*slice cap*/
      slices = append(slices, 8, 9, 10)
      fmt.Printf("改变slice之前: array=%+v, slice=%+v\n", arrary, slices)
      slices[0] = 235
      fmt.Printf("改变slice之后: array=%+v, slice=%+v\n", arrary, slices)

}

经过append操作后，对slice的修改并未影响到arrary，原因在与append的操作令slices重新分配底层数组，所以此时slices的底层数组不在只想前面定义的arrary