Go数组和切片

package main

import "fmt"

func main()  {
   var a [5]int // 声明长度为5的整形数组
   var b [3]int = [3]int{1,2,3} //声明长度为3的整形数组，并初始化
   c := [3]int{1,2,3} // 声明一个数组，并赋值
   d := [...]int{1,2,3} // 声明一个数组， [...]代表数组的长度，由数组初始化时存放的元素个数决定
   e := [...]int{3:11,12,13} // 声明并初始化一个数组，前三位是默认值，后面三位的值是11，12，13

   fmt.Printf("a = %+d \n", a)
   fmt.Printf("b = %+d \n", b)
   fmt.Printf("c = %+d \n", c)
   fmt.Printf("d = %+d \n", d)
   fmt.Printf("e = %+d \n", e)
}
输出结果：
a = [+0 +0 +0 +0 +0] 
b = [+1 +2 +3] 
c = [+1 +2 +3] 
d = [+1 +2 +3] 
e = [+0 +0 +0 +11 +12 +13]

package main

import "fmt"

func main()  {

   arr := [5]int{1,2,3,4,5}
   // 通过数组初始化一个切片
   a := arr[1:3] //指定一个数组下标中一个左闭又开的区间作为切片的初始值
   b := arr[:3]  //省略:左侧的数值，左侧的默认是为0
   c := arr[1:]  //省略:右侧的数值，右侧的默认值是数组的长度
   d := arr[:]   // :左右两侧的数值都省略，默认复制整个数组的值给切片

   // 使用make初始化切片
   e := make([]int,5,10)  //初始化一个长度是5，容量是10的切片
   f := make([]int,5)  //初始化一个长度是5的切片，当不指定容量时，容量默认等于切片的长度


   fmt.Printf("a = %+d \n", a)
   fmt.Printf("b = %+d \n", b)
   fmt.Printf("c = %+d \n", c)
   fmt.Printf("d = %+d \n", d)
   fmt.Printf("e = %+d \n", e)
   fmt.Printf("f = %+d \n", f)


}

package main

import "fmt"

func main()  {

   // 使用make初始化切片
   a := make([]int,5,10)
   fmt.Printf("len = %+d \n", len(a))
   fmt.Printf("cap = %+d \n", cap(a))
}
输出结果：
len = +5 
cap = +10

package main

import (
   "fmt"
)

func main()  {

   s1 := make([]int,5,10)
   s1 = append(s1, 9,10,11) // 往s1中追加 9，10，11 三个元素

   s2 := make([]int,len(s1),10) // 在指定s2的长度时候，默认和s1相同，如果不相同的话会是什么样的呢？
   copy(s2, s1) // 把s1中的值拷贝一份到s2

   fmt.Printf("s1 = %+d \n", s1)
   fmt.Printf("s2 = %+d \n", s2)

   s1 = append(s1, 12,13,14) //继续往s1中添加元素，并超过切片原始的容量10
   fmt.Printf("len(s1) = %+d \n", len(s1))
   fmt.Printf("cap(s1) = %+d \n", cap(s1))

}
输出结果：
s1 = [+0 +0 +0 +0 +0 +9 +10 +11] 
s2 = [+0 +0 +0 +0 +0 +9 +10 +11] 
len(s1) = +11 
cap(s1) = +20

newcap := old.cap
doublecap := newcap + newcap
if cap > doublecap {
   newcap = cap
} else {
   if old.cap < 1024 {
      newcap = doublecap
   } else {
      // Check 0 < newcap to detect overflow
      // and prevent an infinite loop.
      for 0 < newcap && newcap < cap {
         newcap += newcap / 4
      }
      // Set newcap to the requested cap when
      // the newcap calculation overflowed.
      if newcap <= 0 {
         newcap = cap
      }
   }
}

package main

import (
   "fmt"
   "unsafe"
)

func main()  {

   s1 := []int{1,2,3,4,5}
   ptr := unsafe.Pointer(&s1[0]) // unsafe.Pointer方法 用来获取变量所在的内存地址
   fmt.Printf("s1第一元素一开始的地址 = %+d \n", ptr)

   s1 = append(s1, 6,7)
   s1[0] = 100
   fmt.Printf("s1扩容后第一个元素的地址 = %+d \n", unsafe.Pointer(&s1[0]))

   s := (*int)(ptr)
   fmt.Printf("s1第一个元素的数值=%+d",*s)

}

输出结果：
s1第一元素一开始的地址 = +824634318848 
s1扩容后第一个元素的地址 = +824634351616 
s1第一个元素的数值=+1

package main

import "fmt"

func main() {
   arr := [5]int{1, 2, 3, 4, 5}
   s1 := arr[0:2]
   s2 := append(s1, 100)
   fmt.Printf("第一次打印 s1 = %v, Pointer = %p, len = %d, cap = %d\n", s1, &s1, len(s1), cap(s1))
   fmt.Printf("第一次打印 s2 = %v, Pointer = %p, len = %d, cap = %d\n", s2, &s2, len(s2), cap(s2))
   s2[1] += 50
   fmt.Printf("第二次打印 s1 = %v, Pointer = %p, len = %d, cap = %d\n", s1, &s1, len(s1), cap(s1))
   fmt.Printf("第二次打印 s2 = %v, Pointer = %p, len = %d, cap = %d\n", s2, &s2, len(s2), cap(s2))
   fmt.Printf("arr = %v\n", arr)
}
输出结果：
第一次打印 s1 = [1 2], Pointer = 0xc000114000, len = 2, cap = 5
第一次打印 s2 = [1 2 100], Pointer = 0xc000114018, len = 3, cap = 5
第二次打印 s1 = [1 52], Pointer = 0xc000114000, len = 2, cap = 5
第二次打印 s2 = [1 52 100], Pointer = 0xc000114018, len = 3, cap = 5
arr = [1 52 100 4 5]