Go language - structure

An array can be used to store the same type of data array.

To store different types of data, you can try the structure struct.

Definition of structure

type struct_name struct {
     Field name 1     Field type 1
     Field name 2     Field type 2
}

func main() {
	// Format 1
	var p1 Person_struct
	p1.name = "liqi"
	p1.age = 18

	// Format 2
	p2 := Person_struct{}
	p2.name = "liqi"
	p2.age = 19

	// Format 3
	p3 := Person_struct{name: "liqi", age: 20}

	// Format 4
	p4 := Person_struct{
		name: "liqi",
		age:  21,
	}

	// Format 5
	p5 := Person_struct{"liqi", 22}

	fmt.Printf("p1:%v \np2:%v \np3:%v \np4:%v \np5:%v", p1, p2, p3, p4, p5)
}

Structure pointer  

Structure is value type data , So the copy is a deep copy .

If you want to implement shallow copy , It can be realized through structure pointer .

type Person_struct struct {
	name string
	age  int
}

func main() {
	// Format 1
	fmt.Println("--- Format 1---")
	var p1 Person_struct
	p1.name = "liqi"
	p1.age = 18

	var pp1 *Person_struct
	pp1 = &p1

	fmt.Printf("p1 Value :%v ,p1 The type of :%T\n", p1, p1)
	fmt.Printf("p1 The address of :%p\n", &p1)
	fmt.Printf("pp1 Memory address stored :%p\n", pp1)
	fmt.Printf("pp1 Type of storage :%T\n", pp1)
	fmt.Printf("pp1 Stored real values :%v\n", *pp1)

	// Format 2
	fmt.Println("--- Format 2---")

	pp2 := &Person_struct{name: "liqi", age: 19}

	fmt.Printf("pp2 Memory address stored :%p\n", pp2)
	fmt.Printf("pp2 Type of storage :%T\n", pp2)
	fmt.Printf("pp2 Stored real values :%v\n", *pp2)
}

 

Use built-in functions new() Create pointer

new() The function is go A function used to create a week type pointer in .

type Person_struct struct {
	name string
	age  int
}

func main() {
	var p1 Person_struct
	p1.name = "liqi"
	p1.age = 18

	pp1 := new(Person_struct)
	pp1 = &p1

	fmt.Printf("p1 Value :%v ,p1 The type of :%T\n", p1, p1)
	fmt.Printf("p1 The address of :%p\n", &p1)
	fmt.Printf("pp1 Memory address stored :%p\n", pp1)
	fmt.Printf("pp1 Type of storage :%T\n", pp1)
	fmt.Printf("pp1 Stored real values :%v\n", *pp1)
}

Anonymous field of structure

Anonymous structure

Since structures are generally used to store a set of types of data , However, the nomination structure can only be used once , So not often .

struct_name := struct {
     Define fields 
} {
     Field assignment 
}

func main() {
	p1 := struct {
		name string
		age  int
	}{
		name: "John",
		age:  30,
	}

	fmt.Println(p1)
}

 

Anonymous field

Anonymous fields use the data type as the field name by default , therefore Type cannot be repeated .

type struct_name struct {
    type1
    type2
}

type Pserson_struct struct {
	string
	int
}

func main() {
	p1 := Pserson_struct{"zhangsan", 20}
	fmt.Println(p1)
}

 

Nested structure

Because the structure is a value type , So the structure is nested In general, the internal structure will use the structure pointer . Otherwise, the internal structure will be copied .

type Student struct {
	name string
	age  int
	book *Book
}

type Book struct {
	bookName string
	price    float64
}

func main() {
	book1 := Book{"Go Language from the beginning to give up ", 100.0}
	student1 := Student{" Zhang San ", 18, &book1}

	fmt.Println(student1)
	fmt.Println(student1.book)
}

Promotion field  

If a nested structure , An anonymous field is a structure , Then the fields in the structure of this anonymous field are promoted fields .

You can go directly through struct_name. Field name direct access , The name of a structure that does not require a field in the middle .

type Student struct {
	name string
	age  int
	*Book
}

type Book struct {
	bookName string
	price    float64
}

func main() {
	book1 := Book{"Go Language from the beginning to give up ", 100.0}
	student1 := Student{" Zhang San ", 18, &book1}

	fmt.Println(student1)
	fmt.Println(student1.bookName, student1.price)
}