Go结构体

定义结构体

结构体是一种聚合的数据类型，是由零个或多个任意类型的值聚合成的实体。每个值称为结构体的成员。

结构体定义的一般方式如下：

type identifier struct {    field1 type1    field2 type2    ...}

type T struct {a, b int} 也是合法的语法，它更适用于简单的结构体。

结构体里的字段都有 名字，像 field1、field2 等，如果字段在代码中从来也不会被用到，那么可以命名它为 _。

结构体的字段可以是任何类型，甚至是结构体本身，也可以是函数或者接口。可以声明结构体类型的一个变量，然后像下面这样给它的字段赋值：

var s Ts.a = 5s.b = 8

 

初始化结构体的三种方式

使用new 

使用 new 函数给一个新的结构体变量分配内存，它返回指向已分配内存的指针：var t *T = new(T)，如果需要可以把这条语句放在不同的行（比如定义是包范围的，但是分配却没有必要在开始就做）。

var t *Tt = new(T)

写这条语句的惯用方法是：t := new(T)，变量 t 是一个指向 T的指针，此时结构体字段的值是它们所属类型的零值。

t 通常被称做类型 T 的一个实例（instance）或对象（object）。

package mainimport "fmt"type struct1 struct {    i1  int    f1  float32    str string}func main() {    ms := new(struct1)    ms.i1 = 10    ms.f1 = 15.5    ms.str= "Chris"    fmt.Printf("The int is: %d\n", ms.i1)    fmt.Printf("The float is: %f\n", ms.f1)    fmt.Printf("The string is: %s\n", ms.str)    fmt.Println(ms)}

使用 &T{...}

&T{...} 是一种简写，底层仍然会调用 new ()，这里值的顺序必须按照字段顺序来写。

表达式 new(Type) 和 &Type{} 是等价的。

package mainimport (    "fmt"    "strings")type Person struct {    firstName   string    lastName    string}func upPerson(p *Person) {    p.firstName = strings.ToUpper(p.firstName)    p.lastName = strings.ToUpper(p.lastName)}func main() {    // 3—struct as a literal:    pers3 := &Person{"Chris","Woodward"}    upPerson(pers3)    fmt.Printf("The name of the person is %s %s\n", pers3.firstName, pers3.lastName)}

作为值类型初始化

一般使用 var t T 声明一个结构体类型的值类型，同时也会分配内存，只是零值化内存，但是这个时候 t 是类型T。

package mainimport (	"fmt"	"log"	"reflect")type Notifier interface {	Notify() error}type User struct {	Name  string	Email string}func (u *User) Notify() error {	log.Printf("User: Sending User Email To %s<%s>\n", u.Name, u.Email)	return nil}func SendNotification(notify Notifier) error {	return notify.Notify()}func main() {	//它返回了一个指针，指向新分配的类型 T 的零值。	newUser := new(User)	userPointer := &User{		Name:  "AriesDevil",		Email: "ariesdevil@xxoo.com",	}	user := User{		Name:  "AriesDevil",		Email: "ariesdevil@xxoo.com",	}	var userVar User	userVar.Email = "hellolyx1618@gmail.com"	userVar.Name = "hello world"	fmt.Println(reflect.TypeOf(newUser))	fmt.Printf("Email = %s , Name = %s \n", newUser.Email, newUser.Name) //	fmt.Println(reflect.TypeOf(userPointer))	fmt.Println(reflect.TypeOf(user))	fmt.Println(reflect.TypeOf(userVar))	// 输出	//*main.User	//*main.User	//main.User	//main.User}

 

使用工厂方法创建结构体

Go 语言不支持面向对象编程语言中那样的构造子方法，但是可以很容易的在 Go 中实现 “构造子工厂”方法。为了方便通常会为类型定义一个工厂，按惯例，工厂的名字以 new 或 New 开头。假设定义了如下的 File 结构体类型：

type File struct {    fd      int     // 文件描述符    name    string  // 文件名}

下面是这个结构体类型对应的工厂方法，它返回一个指向结构体实例的指针：

func NewFile(fd int, name string) *File {    if fd < 0 {        return nil    }    return &File{fd, name}}

然后这样调用它：

f := NewFile(10, "./test.txt")

在 Go 语言中常常像上面这样在工厂方法里使用初始化来简便的实现构造函数。

如果 File 是一个结构体类型，那么表达式 new(File) 和 &File{} 是等价的。

我们可以说是工厂实例化了类型的一个对象，就像在基于类的OO语言中那样。

如果想知道结构体类型T的一个实例占用了多少内存，可以使用：size := unsafe.Sizeof(T{})。

如何强制使用工厂方法

禁止使用 new 函数，强制用户使用工厂方法，那就是把类型私有的，结构体名称开头小写。

type matrix struct {    ...}func NewMatrix(params) *matrix {    m := new(matrix) // 初始化 m    return m}

在其他包里使用工厂方法：

package mainimport "matrix"...wrong := new(matrix.matrix)     // 编译失败（matrix 是私有的）right := matrix.NewMatrix(...)  // 实例化 matrix 的唯一方式

 

匿名字段和内嵌结构体

结构体可以包含一个或多个 匿名（或内嵌）字段，即这些字段没有显式的名字，只有字段的类型是必须的，此时类型就是字段的名字。匿名字段本身可以是一个结构体类型，即 结构体可以包含内嵌结构体。

可以粗略地将这个和面向对象语言中的继承概念相比较，随后将会看到它被用来模拟类似继承的行为。Go 语言中的继承是通过内嵌或组合来实现的，所以可以说，在 Go 语言中，相比较于继承，组合更受青睐。

考虑如下的程序：

package mainimport "fmt"type innerS struct {    in1 int    in2 int}type outerS struct {    b    int    c    float32    int  // anonymous field    innerS //anonymous field}func main() {    outer := new(outerS)    outer.b = 6    outer.c = 7.5    outer.int = 60    outer.in1 = 5    outer.in2 = 10    fmt.Printf("outer.b is: %d\n", outer.b)    fmt.Printf("outer.c is: %f\n", outer.c)    fmt.Printf("outer.int is: %d\n", outer.int)    fmt.Printf("outer.in1 is: %d\n", outer.in1)    fmt.Printf("outer.in2 is: %d\n", outer.in2)    // 使用结构体字面量    outer2 := outerS{6, 7.5, 60, innerS{5, 10}}    fmt.Println("outer2 is:", outer2)}

输出

outer.b is: 6outer.c is: 7.500000outer.int is: 60outer.in1 is: 5outer.in2 is: 10outer2 is:{6 7.5 60 {5 10}}

通过类型 outer.int 的名字来获取存储在匿名字段中的数据，于是可以得出一个结论：在一个结构体中对于每一种数据类型只能有一个匿名字段。

内嵌结构体

同样地结构体也是一种数据类型，所以它也可以作为一个匿名字段来使用，如同上面例子中那样。外层结构体通过 outer.in1 直接进入内层结构体的字段，内嵌结构体甚至可以来自其他包。内层结构体被简单的插入或者内嵌进外层结构体。这个简单的“继承”机制提供了一种方式，使得可以从另外一个或一些类型继承部分或全部实现。

另外一个例子：

package mainimport "fmt"type A struct {    ax, ay int}type B struct {    A    bx, by float32}func main() {    b := B{A{1, 2}, 3.0, 4.0}    fmt.Println(b.ax, b.ay, b.bx, b.by)    fmt.Println(b.A)}

输出：

1 2 3 4{1 2}

==========END==========