深入源码分析go类型系统
Ø runtime/type.h
go类型描述的静态信息
|
//type go类型最通用定义，go的类型系统通过这个数据结构来进行驱动 //Type是类型信息结构体中公共的部分 20 struct Type 21 { 22 uintptr size; //类型大小 23 uint32 hash; //hash值 24 uint8 _unused; 25 uint8 align; //对齐 26 uint8 fieldAlign; //field对齐 27 uint8 kind; //reflect包中的Kind类型就是这个，它是个类型的枚举值 28 Alg *alg; 29 void *gc; //垃圾回收相关 30 String *string; 31 UncommonType *x; //指向指针，该指针指向的struct 中包含该类型实现的函数指针数组 32 Type *ptrto; 33 byte *zero; // ptr to the zero value for this type 34 }; |
|
// 非接口类型method描述数据结构 36 struct Method 37 { 38 String *name; 39 String *pkgPath; 40 Type *mtyp; 41 Type *typ; 42 void (*ifn)(void); 43 void (*tfn)(void); 44 }; 45 //具体类型的methods集合 46 struct UncommonType 47 { 48 String *name; 49 String *pkgPath; 50 Slice mhdr; 51 Method m[]; 52 }; |
|
//有methods 的interface 编译器构造的静态数据结构 54 struct IMethod 55 { 56 String *name; 57 String *pkgPath; 58 Type *type; 59 }; 60 61 struct InterfaceType 62 { 63 Type; 64 Slice mhdr; 65 IMethod m[]; 66 };
// 空接口interface{} 编译器不会为该种类型构造一个静态数据结构 空接口在赋值后才有意义，单单声明个空接口是没有意义的
|
Ø runtime/type.h
//接口赋值时编译器构造的动态数据结构
|
//其他类型赋值给interfac{}，编译器动态构造的数据结构 189 struct Eface 190 { 191 Type* type; //指向具体类型 192 void* data; //类型变量的值 193 };
|
|
//其他类型赋值给非空接口，编译器构造的数据结构 184 struct Iface 185 { 186 Itab* tab; //接口动态赋值时数据结构 187 void* data; //类型值 188 };
// 具体类型变量赋值给非空接口类型变量时，编译器构造的数据结构 472 struct Itab 473 { 474 InterfaceType* inter; //指向接口静态类型描述，见上文InterfaceType结构 475 Type* type; //指向结构被赋值的具体变量的类型描述 476 Itab* link; 477 int32 bad; 478 int32 unused; 479 void (*fun[])(void); //拷贝具体类型变量的函数指针到该数组 480 }; |
|
|
|
|
l 接口是可被实例化的类型，不仅是语言上的约束规范；当我们创建接变量时，将会为其分配部分内存空间（此时接口没有任何价值，不能使用）；当将type实例赋值时给接口变量时才分配全部空间（包括实例变量值或指针的拷贝）和初始化全部数据结构。单单声明一个接口变量，而不对其赋值，是没有意义的。
|
$GOROOT/src/pkg/runtime/runtime.h
178 struct Iface 179 { 180 Itab* tab; 181 void* data; 182 };
449 struct Itab 450 { 451 InterfaceType* inter; 452 Type* type; 453 Itab* link; 454 int32 bad; 455 int32 unused; 456 void (*fun[])(void); 457 };
|
|
上个例子中： var m Tester 仅仅创建Iface 数据结构，但是 Itab 和 void * data 都没有赋值（nil），此时变量m 没有任何意义，使用m 会引发运行时panic （对m进行反射TypeOf 返回nil） （对m进行反射ValueOf 返回空的value，调用其方法会引发panic） 只有给m 赋值一个type 实例变量，才会初始化Itab 和 void * data，接口变量才能真的使用
接口变量是用来赋值的，单单声明一个接口变量而不赋值违背了接口设计原则； 接口是用来结构的，接口变量一定要实例化（被赋值）； 接口变量可以赋值给另一个接口变量；
|
反射包是对go类型的更深一个层次抽象，其与go底层数据结构的映射关系如下：
|
描述类型的数据结构 |
描述类型变量存储结构的数据结构 |
|
runtime/type.h |
runtime/runtime.h |
|
reflect/type.go |
reflect/value.go |
Type结构
类型信息是静态的，声明一种新类型，编译器只需生成一个该类型的数据结构描述即可；
类型变量是动态的，new或者直接声明一个变量，都要为该变量分配存储空间，同时将该变量与类型信息关联；以便在调用类型方法的时候能够找到正确的入口地址和参数；
编译器在编译时即已经确定类型信息和类型方法，在运行时将参数值和调用类型方法绑定，完成方法调用；
go大部分类型检查是在编译器进行的（包括接口赋值），有两个例外是在运行期进行的：
1> 调用反射的方法
2> 接口的查询 t.(TYPE)
|
接口操作 |
语法 |
时间点 |
|
类型变量赋值给接口 |
var i InterfaceA = &structA{} |
编译期间 |
|
接口查询 |
var i InterfaceA = &structA{} v, ok := i.(TypeB) |
运行期间 |
|
接口变量赋值给接口变量 |
var rw IReadWriter = ... var r IReader = rw |
编译期间 |
|
数据结构 |
runtime/type.h |
reflect/type.go |
|
type |
20 struct Type 21 { 22 uintptr size; 23 uint32 hash; 24 uint8 _unused; 25 uint8 align; 26 uint8 fieldAlign; 27 uint8 kind; 28 Alg *alg; 29 void *gc; 30 String *string; 31 UncommonType *x; 32 Type *ptrto; 33 byte *zero; // ptr to the zero value for this type 34 }; |
244 type rtype struct {
245 size uintptr // size in bytes 246 hash uint32 // hash of type; avoids computation in hash tables 247 _ uint8 // unused/padding 248 align uint8 // alignment of variable with this type 249 fieldAlign uint8 // alignment of struct field with this type 250 kind uint8 // enumeration for C 251 alg *uintptr // algorithm table (../runtime/runtime.h:/Alg) 252 gc unsafe.Pointer // garbage collection data 253 string *string // string form; unnecessary but undeniably useful 254 *uncommonType // (relatively) uncommon fields 255 ptrToThis *rtype // type for pointer to this type, if used in binary or has methods 256 zero unsafe.Pointer // pointer to zero value 257 } |
|
UncommonType 非接口类型静态数据结构 |
36 struct Method 37 { 38 String *name; 39 String *pkgPath; 40 Type *mtyp; 41 Type *typ; 42 void (*ifn)(void); 43 void (*tfn)(void); 44 }; 45 46 struct UncommonType 47 { 48 String *name; 49 String *pkgPath; 50 Slice mhdr; 51 Method m[]; 52 }; |
260 type method struct {
261 name *string // name of method 262 pkgPath *string // nil for exported Names; otherwise import path 263 mtyp *rtype // method type (without receiver) 264 typ *rtype // .(*FuncType) underneath (with receiver) 265 ifn unsafe.Pointer // fn used in interface call (one-word receiver) 266 tfn unsafe.Pointer // fn used for normal method call 267 } 273 type uncommonType struct { 274 name *string // name of type 275 pkgPath *string // import path; nil for built-in types like int, string 276 methods []method // methods associated with type 277 } |
|
InterfaceType 非空接口类型数据结构 |
54 struct IMethod 55 { 56 String *name; 57 String *pkgPath; 58 Type *type; 59 }; 60 61 struct InterfaceType 62 { 63 Type; 64 Slice mhdr; 65 IMethod m[]; 66 }; |
311 // imethod represents a method on an interface type 312 type imethod struct { 313 name *string // name of method 314 pkgPath *string // nil for exported Names; otherwise import path 315 typ *rtype // .(*FuncType) underneath 316 } 317 318 // interfaceType represents an interface type. 319 type interfaceType struct { 320 rtype `reflect:"interface"` 321 methods []imethod // sorted by hash 322 } |
|
内置数据类型 |
68 struct MapType 69 { 70 Type; 71 Type *key; 72 Type *elem; 73 Type *bucket; 74 Type *hmap; 75 };
77 struct ChanType 78 { 79 Type; 80 Type *elem; 81 uintptr dir; 82 };
84 struct SliceType 85 { 86 Type; 87 Type *elem; 88 };
90 struct FuncType 91 { 92 Type; 93 bool dotdotdot; 94 Slice in; 95 Slice out; 96 } 97 98 struct PtrType 99 { 100 Type; 101 Type *elem; 102 };
|
325 type mapType struct { 326 rtype `reflect:"map"` 327 key *rtype // map key type 328 elem *rtype // map element (value) type 329 bucket *rtype // internal bucket structure 330 hmap *rtype // internal map header 331 }
296 // chanType represents a channel type. 297 type chanType struct { 298 rtype `reflect:"chan"` 299 elem *rtype // channel element type 300 dir uintptr // channel direction (ChanDir) 301 }
339 // sliceType represents a slice type. 340 type sliceType struct { 341 rtype `reflect:"slice"` 342 elem *rtype // slice element type 343 }
303 // funcType represents a function type. 304 type funcType struct { 305 rtype `reflect:"func"` 306 dotdotdot bool // last input parameter is ... 307 in []*rtype // input parameter types 308 out []*rtype // output parameter types 309 }
333 // ptrType represents a pointer type. 334 type ptrType struct { 335 rtype `reflect:"ptr"` 336 elem *rtype // pointer element (pointed at) type 337 }
289 type arrayType struct { 290 rtype `reflect:"array"` 291 elem *rtype // array element type 292 slice *rtype // slice type 293 len uintptr 294 }
|
|
|
|
345 // Struct field 346 type structField struct { 347 name *string // nil for embedded fields 348 pkgPath *string // nil for exported Names; otherwise import path 349 typ *rtype // type of field 350 tag *string // nil if no tag 351 offset uintptr // byte offset of field within struct 352 } 353 354 // structType represents a struct type. 355 type structType struct { 356 rtype `reflect:"struct"` 357 fields []structField // sorted by offset 358 } |
|
go支持类型系统
struct 类型比较特殊，他是一种符合类型
函数也是一等公民，也是一种基础类型 |
|
210 const ( 211 Invalid Kind = iota 212 Bool 213 Int 214 Int8 215 Int16 216 Int32 217 Int64 218 Uint 219 Uint8 220 Uint16 221 Uint32 222 Uint64 223 Uintptr 224 Float32 225 Float64 226 Complex64 227 Complex128 228 Array 229 Chan 230 Func 231 Interface 232 Map 233 Ptr 234 Slice 235 String 236 Struct 237 UnsafePointer 238 ) |
Value具体映射关系
value 主要是描述类型变量的内存布局
接口是个粘合剂，go在编译时也准备一些数据结构来辅助变量间的运算
|
数据结构 |
runtime/runtime.h |
reflect/value.go |
|
空接口 |
//空接口 189 struct Eface 190 { 191 Type* type; 192 void* data; 193 };
|
//空接口 278 // emptyInterface is the header for an interface{} value. 279 type emptyInterface struct { 280 typ *rtype 281 word iword 282 } 283 |
|
非空接口 |
//非空接口数据描述 184 struct Iface 185 { 186 Itab* tab; 187 void* data; 188 }; 470 // layout of Itab known to compilers 471 // allocated in non-garbage-collected memory 472 struct Itab 473 { 474 InterfaceType* inter; 475 Type* type; 476 Itab* link; 477 int32 bad; 478 int32 unused; 479 void (*fun[])(void); 480 }; |
////非空接口数据描述 284 // nonEmptyInterface is the header for a interface value with methods. 285 type nonEmptyInterface struct { 286 // see ../runtime/iface.c:/Itab 287 itab *struct { 288 ityp *rtype // static interface type 289 typ *rtype // dynamic concrete type 290 link unsafe.Pointer 291 bad int32 292 unused int32 293 fun [100000]unsafe.Pointer // method table 294 } 295 word iword 296 } |
|
内置数据类型存储模型 |
205 struct Slice 206 { 207 byte* array; 208 uintgo len; 209 uintgo cap; 210 };
174 struct String 175 { 176 byte* str; 177 intgo len; 178 };
194 struct Complex64 195 { 196 float32 real; 197 float32 imag; 198 }; 199 struct Complex128 200 { 201 float64 real; 202 float64 imag; 203 };
|
1931 type SliceHeader struct { 1932 Data uintptr 1933 Len int 1934 Cap int 1935 }
1914 type StringHeader struct { 1915 Data uintptr 1916 Len int 1917 } |
|
Layout of in-memory per-function information prepared by linker 由连接器在内存中位每个函数分配的信息 |
455 struct Func 456 { 457 uintptr entry; // start pc 458 int32 nameoff;// function name 459 460 int32 args; // in/out args size 461 int32 frame; // legacy frame size; use pcsp if possible 462 463 int32 pcsp; 464 int32 pcfile; 465 int32 pcln; 466 int32 npcdata; 467 int32 nfuncdata; 468 }; |
|
有疑问加站长微信联系（非本文作者）
