Golang 语言的内存管理

type stringStruct struct {
 str unsafe.Pointer
 len int
}
// Variant with *byte pointer type for DWARF debugging.
type stringStructDWARF struct {
 str *byte
 len int
}

str := "hello北京"
fmt.Println(len(str)) //11
fmt.Println(utf8.RuneCountInString(str)) // 7
for index, runeValue := range str {
  fmt.Printf("%d: %c\n", index, runeValue)
}
// 0:h
// 1:e
// 2:l
// 3:l
// 4:o
// 5:北
// 8:京

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

a := []int{1}
fmt.Printf("len: %d cap: %d data: %+v\n", len(a), cap(a), a)
a = append(a, 2)
fmt.Printf("len: %d cap: %d data: %+v\n", len(a), cap(a), a)
a = append(a, 3)
fmt.Printf("len: %d cap: %d data: %+v\n", len(a), cap(a), a)
a = append(a, 4, 5)
fmt.Printf("len: %d cap: %d data: %+v\n", len(a), cap(a), a)
// 输出结果：
// len: 1 cap: 1 data: [1]
// len: 2 cap: 2 data: [1 2]
// len: 3 cap: 4 data: [1 2 3]
// len: 5 cap: 8 data: [1 2 3 4 5]

func main() {
  a := []int{1,2,3}
  fmt.Printf("len: %d cap: %d data: %+v\n", len(a), cap(a), a)
  appendSlice(a)
  fmt.Printf("len: %d cap: %d data: %+v\n", len(a), cap(a), a)
}
func appendSlice(a []int) {
  a = append(a, 4)
}
// 输出结果：
// len: 3 cap: 3 data: [1 2 3]
// len: 3 cap: 3 data: [1 2 3]

func appendSlice(a []int) []int {
  a = append(a, 4)
  return a
}

func main() {
  a := []int{1,2,3}
  fmt.Printf("len: %d cap: %d data: %+v\n", len(a), cap(a), a)
  appendSlice(a)
  fmt.Printf("len: %d cap: %d data: %+v\n", len(a), cap(a), a)
}
func appendSlice(a *[]int) {
  *a = append(*a, 4)
}
// 输出结果：
// len: 3 cap: 3 data: [1 2 3]
// len: 4 cap: 6 data: [1 2 3 4]

// A header for a Go map.
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
}

type Stringer interface {
  String() string
}
type Binary uint64
func (i Binary) String() string {
  return strconv.FormatUint(i.Get(), 2)
}
func (i Binary) Get() uint64 {
  return uint64(i)
}
func main() {
  var b Binary = 200
  s := Stringer(b)
  fmt.Print(s.String())
}

type hchan struct {
 qcount   uint           // total data in the queue
 dataqsiz uint           // size of the circular queue
 buf      unsafe.Pointer // points to an array of dataqsiz elements
 elemsize uint16
 closed   uint32
 elemtype *_type // element type
 sendx    uint   // send index
 recvx    uint   // receive index
 recvq    waitq  // list of recv waiters
 sendq    waitq  // list of send waiters
 // lock protects all fields in hchan, as well as several
 // fields in sudogs blocked on this channel.
 //
 // Do not change another G's status while holding this lock
 // (in particular, do not ready a G), as this can deadlock
 // with stack shrinking.
 lock mutex
}

type S struct {}
func main() {
  var x S
  _ = *ref(x)
}
func ref(z S) *S {
  return &z
}