golang: 常用數據類型底層結構分析

jopen 10年前發布 | 86K 次閱讀 Golang Google Go/Golang開發

雖然golang是用C實現的，并且被稱為下一代的C語言，但是golang跟C的差別還是很大的。它定義了一套很豐富的數據類型及數據結構，這些類型和結構或者是直接映射為C的數據類型，或者是用C struct來實現。了解golang的數據類型和數據結構的底層實現，將有助于我們更好的理解golang并寫出質量更好的代碼。

基礎類型

源碼在：$GOROOT/src/pkg/runtime/runtime.h 。我們先來看下基礎類型：

/*
 * basic types
 */
typedef signed char             int8;
typedef unsigned char           uint8;
typedef signed short            int16;
typedef unsigned short          uint16;
typedef signed int              int32;
typedef unsigned int            uint32;
typedef signed long long int    int64;
typedef unsigned long long int  uint64;
typedef float                   float32;
typedef double                  float64;

#ifdef _64BIT
typedef uint64          uintptr;
typedef int64           intptr;
typedef int64           intgo; // Go's int
typedef uint64          uintgo; // Go's uint
#else
typedef uint32          uintptr;
typedef int32           intptr;
typedef int32           intgo; // Go's int
typedef uint32          uintgo; // Go's uint
#endif

/*
 * defined types
 */
typedef uint8           bool;
typedef uint8           byte;

int8、uint8、int16、uint16、int32、uint32、int64、uint64、float32、float64分別對應于C的類型，這個只要有C基礎就很容易看得出來。uintptr和intptr是無符號和有符號的指針類型，并且確保在64位平臺上是8個字節，在32位平臺上是4個字節，uintptr主要用于golang中的指針運算。而intgo和uintgo之所以不命名為int和uint，是因為int在C中是類型名，想必uintgo是為了跟intgo的命名對應吧。intgo和uintgo對應golang中的int和uint。從定義可以看出int和uint是可變大小類型的，在64位平臺上占8個字節，在32位平臺上占4個字節。所以如果有明確的要求，應該選擇int32、int64或uint32、uint64。byte類型的底層類型是uint8。可以看下測試：

package main

import (
        "fmt"
        "reflect"
)

func main() {
        var b byte = 'D'
        fmt.Printf("output: %v\n", reflect.TypeOf(b).Kind())
}

$ cd $GOPATH/src/basictype_test
$ go build
$ ./basictype_test
output: uint8

數據類型分為靜態類型和底層類型，相對于以上代碼中的變量b來說，byte是它的靜態類型，uint8是它的底層類型。這點很重要，以后經常會用到這個概念。

rune類型

rune是int32的別名，用于表示unicode字符。通常在處理中文的時候需要用到它，當然也可以用range關鍵字。

string類型

string類型的底層是一個C struct。

struct String
{
        byte*   str;
        intgo   len;
};

成員str為字符數組，len為字符數組長度。golang的字符串是不可變類型，對string類型的變量初始化意味著會對底層結構的初始化。至于為什么str用byte類型而不用rune類型，這是因為golang的for循環對字符串的遍歷是基于字節的，如果有必要，可以轉成rune切片或使用range來迭代。我們來看個例子：

$GOPATH/src

----basictype_test

--------main.go

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)
}

$ cd $GOPATH/src/basictype_test
$ go build
$ ./basictype_test
output: &{str:135100456 len:14}

內建函數len對string類型的操作是直接從底層結構中取出len值，而不需要額外的操作，當然在初始化時必需同時初始化len的值。

slice類型

slice類型的底層同樣是一個C struct。

struct Slice
{               // must not move anything
    byte*   array;      // actual data
    uintgo  len;        // number of elements
    uintgo  cap;        // allocated number of elements
};

包括三個成員。array為底層數組，len為實際存放的個數，cap為總容量。使用內建函數make對slice進行初始化，也可以類似于數組的方式進行初始化。當使用make函數來對slice進行初始化時，第一個參數為切片類型，第二個參數為len，第三個參數可選，如果不傳入，則cap等于len。通常傳入cap參數來預先分配大小的slice，避免頻繁重新分配內存。

package main

import (
    "fmt"
    "unsafe"
)

func main() {
    var slice []int32 = make([]int32, 5, 10)
    p := (*struct {
        array uintptr
        len   int
        cap   int
    })(unsafe.Pointer(&slice))

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

$ cd $GOPATH/src/basictype_test
$ go build
$ ./basictype_test
output: &{array:406958176 len:5 cap:10}

由于切片指向一個底層數組，并且可以通過切片語法直接從數組生成切片，所以需要了解切片和數組的關系，否則可能就會不知不覺的寫出有bug的代碼。比如有如下代碼：

package main

import (
    "fmt"
)

func main() {
    var array = [...]int32{1, 2, 3, 4, 5}
    var slice = array[2:4]
    fmt.Printf("改變slice之前: array=%+v, slice=%+v\n", array, slice)
    slice[0] = 234
    fmt.Printf("改變slice之后: array=%+v, slice=%+v\n", array, slice)
}

$ cd $GOPATH/src/basictype_test
$ go build
$ ./basictype_test
改變slice之前: array=[1 2 3 4 5], slice=[3 4]
改變slice之后: array=[1 2 234 4 5], slice=[234 4]

您可以清楚的看到，在改變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"
)

func main() {
    var array = [...]int32{1, 2, 3, 4, 5}
    var slice = array[2:4]
    slice = append(slice, 6, 7, 8)
    fmt.Printf("改變slice之前: array=%+v, slice=%+v\n", array, slice)
    slice[0] = 234
    fmt.Printf("改變slice之后: array=%+v, slice=%+v\n", array, slice)
}

$ cd $GOPATH/src/basictype_test
$ go build
$ ./basictype_test
改變slice之前: array=[1 2 3 4 5], slice=[3 4 6 7 8]
改變slice之后: array=[1 2 3 4 5], slice=[234 4 6 7 8]

經過append操作之后，對slice的修改并未影響到array。原因在于append的操作令slice重新分配底層數組，所以此時slice的底層數組不再指向前面定義的array。

但是很顯然，這種規則對從切片生成的切片也是同樣的，請看代碼：

package main

import (
    "fmt"
)

func main() {
    var slice1 = []int32{1, 2, 3, 4, 5}
    var slice2 = slice1[2:4]
    fmt.Printf("改變slice2之前: slice1=%+v, slice2=%+v\n", slice1, slice2)
    slice2[0] = 234
    fmt.Printf("改變slice2之后: slice1=%+v, slice2=%+v\n", slice1, slice2)
}

$ cd $GOPATH/src/basictype_test
$ go build
$ ./basictype_test
改變slice2之前: slice1=[1 2 3 4 5], slice2=[3 4]
改變slice2之后: slice1=[1 2 234 4 5], slice2=[234 4]

slice1和slice2共用一個底層數組，修改slice2的元素導致slice1也發生變化。

package main

import (
    "fmt"
)

func main() {
    var slice1 = []int32{1, 2, 3, 4, 5}
    var slice2 = slice1[2:4]
    fmt.Printf("改變slice2之前: slice1=%+v, slice2=%+v\n", slice1, slice2)
    slice2 = append(slice2, 6, 7, 8)
    fmt.Printf("改變slice2之后: slice1=%+v, slice2=%+v\n", slice1, slice2)
}

$ cd $GOPATH/src/basictype_test
$ go build
$ ./basictype_test
改變slice2之前: slice1=[1 2 3 4 5], slice2=[3 4]
改變slice2之后: slice1=[1 2 3 4 5], slice2=[3 4 6 7 8]

而append操作可令slice1或slice2重新分配底層數組，因此對slice1或slice2執行append操作都不會相互影響。

接口類型

接口在golang中的實現比較復雜，在$GOROOT/src/pkg/runtime/type.h中定義了：

struct Type
{
    uintptr size;
    uint32 hash;
    uint8 _unused;
    uint8 align;
    uint8 fieldAlign;
    uint8 kind;
    Alg *alg;
    void *gc;
    String *string;
    UncommonType *x;
    Type *ptrto;
};

在$GOROOT/src/pkg/runtime/runtime.h中定義了：

struct Iface
{
    Itab*   tab;
    void*   data;
};
struct Eface
{
    Type*   type;
    void*   data;
};
struct  Itab
{
    InterfaceType*  inter;
    Type*   type;
    Itab*   link;
    int32   bad;
    int32   unused;
    void    (*fun[])(void);
};

interface實際上是一個結構體，包括兩個成員，一個是指向數據的指針，一個包含了成員的類型信息。Eface是interface{}底層使用的數據結構。因為interface中保存了類型信息，所以可以實現反射。反射其實就是查找底層數據結構的元數據。完整的實現在：$GOROOT/src/pkg/runtime/iface.c 。

package main

import (
    "fmt"
    "unsafe"
)

func main() {
    var str interface{} = "Hello World!"
    p := (*struct {
        tab  uintptr
        data uintptr
    })(unsafe.Pointer(&str))

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

$ cd $GOPATH/src/basictype_test
$ go build
$ ./basictype_test
output: &{tab:134966528 data:406847688}

map類型

golang的map實現是hashtable，源碼在：$GOROOT/src/pkg/runtime/hashmap.c 。

struct Hmap
{
    uintgo  count;
    uint32  flags;
    uint32  hash0;
    uint8   B;
    uint8   keysize;
    uint8   valuesize;
    uint16  bucketsize;

    byte    *buckets;
    byte    *oldbuckets;
    uintptr nevacuate;
};

測試代碼如下：

package main

import (
    "fmt"
    "unsafe"
)

func main() {
    var m = make(map[string]int32, 10)
    m["hello"] = 123
    p := (*struct {
        count      int
        flags      uint32
        hash0      uint32
        B          uint8
        keysize    uint8
        valuesize  uint8
        bucketsize uint16

        buckets    uintptr
        oldbuckets uintptr
        nevacuate  uintptr
    })(unsafe.Pointer(&m))

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

$ cd $GOPATH/src/basictype_test
$ go build
$ ./basictype_test
output: &{count:407032064 flags:0 hash0:134958144 B:192 keysize:0 valuesize:64 bucketsize:30063 buckets:540701813 oldbuckets:0 nevacuate:0}

golang的坑還是比較多的，需要深入研究底層，否則很容易掉坑里。

本文由用戶 jopen 自行上傳分享，僅供網友學習交流。所有權歸原作者，若您的權利被侵害，請聯系管理員。

轉載本站原創文章，請注明出處，并保留原始鏈接、圖片水印。

本站是一個以用戶分享為主的開源技術平臺，歡迎各類分享！

本文地址：http://www.baiduhome.net/lib/view/open1391347613192.html

Golang Google Go/Golang開發