1. 结构体 struct

1.1 概述

structclass结构体成员成员变量字段方法组合

1.2. 定义结构体

type
type 结构体名称 struct{
    字段1 类型
    字段2 类型
    字段3 类型
    ...
}
  • 结构体名称 : 标识自定义结构体的名称 ,在同一包内不能重复
  • struct{} : 标识这是个结构体类型
  • 字段: 表示结构体中的字段名,在一个结构体中字段名必须是唯一
  • 类型: 表示对应的结构体的数据类型,
package main
//定义一个Color的结构体
type Color struct {
	R,G,B byte
}
// 定义一个point 结构体
type Point struct {
	x int64
	y int64
}
// 定义一个Student的结构体
type Student struct {
	name string
	age int
	course []string
	score map[string]int
	average float32
	graduate bool
}
func main(){

}

1.3 实例化结构体

.
var
package main

import "fmt"

type Student struct {
	name     string
	age      int
	course   []string
	score    map[string]int
	average  float32
	graduate bool
}

func main() {
	// 实例化方式1
	var stu1  Student
	fmt.Println(stu1)
}

实例化方法2

package main

import "fmt"

type Student struct {
	name     string
	age      int
	course   []string
	score    map[string]int
	average  float32
	graduate bool
}

func main() {
	// 实例化方式2
	var stu2 Student = Student{}
	fmt.Println(stu2)
}

new
package main

import "fmt"

type Student struct {
	name     string
	age      int
	course   []string
	score    map[string]int
	average  float32
	graduate bool
}

func main() {
	// 实例化方式1
	var stu3 *Student = new(Student)
	fmt.Println(stu3)
}

go run main.go
&{ 0 [] map[] 0 false}

&
package main

import "fmt"

type Student struct {
	name     string
	age      int
	course   []string
	score    map[string]int
	average  float32
	graduate bool
}

func main() {
	// 实例化方法4
	var stu4 *Student = &Student{}
	fmt.Println(stu4)
}

go run main.go
&{ 0 [] map[] 0 false}

1.4 初始化结构体成员变量

结构体在实例化时,或者之后都可以对其成员变量进行初始化

package main

import "fmt"

type Student struct {
	name     string
	age      int
	course   []string
	score    map[string]int
	average  float32
	graduate bool
}

func main() {
	var stu1  Student
	// 结构体变量成员初始化1 访问结构体字段方式赋值
	stu1.name = "张三"
	stu1.age = 70
	// slice 和 map 都需要make之后才能使用
	stu1.course = make([]string,3)
	stu1.course[0] = "数学"
	stu1.course[1] = "物理"
	stu1.course[2] = "化学"
	fmt.Println(stu1)
	// 结构体变量成员初始化2 键值对形式赋值
	var stu2 Student = Student{
		name:"李四",
		age:70,
		course:[]string{"语文","地理"},
		score: map[string]int{"语文":120,"地理":90},
		average:105.0,
		graduate:false,
	}
	fmt.Println(stu2)
	// 结构体变量成员初始化3 值列表形式赋值
	stu3 := Student{
		"王五",
		70,
		[]string{"音乐","美术"},
		map[string]int{"音乐":90,"美术":80},
		85.0,
		true,
	}
	fmt.Println(stu3)
}


go run main.go
{张三 70 [数学 物理 化学] map[] 0 false}
{李四 70 [语文 地理] map[地理:90 语文:120] 105 false}
{王五 70 [音乐 美术] map[美术:80 音乐:90] 85 true}

(*结构体指针).字段名(*stu).name = "赵六"结构体.字段名stu.name = "秦七"stu.name(*stu).name
package main

import "fmt"

type Student struct {
	name     string
	age      int
	course   []string
	score    map[string]int
	average  float32
	graduate bool
}
func main() {
	var stu *Student = new(Student)
	fmt.Println(stu)
	// 结构体变量stu是结构体指针那么访问结构体成员
	(*stu).name = "赵六"
	fmt.Println(*stu)
	// 一般的方法访问结构体成员变量
    stu.name = "秦七" // (*stu).name = "秦七"
	fmt.Println(*stu)
}


go run main.go
&{ 0 [] map[] 0 false}
{赵六 0 [] map[] 0 false}
{秦七 0 [] map[] 0 false}

1.5 结构体变量复制

结构体变量作为值赋给另外的变量是值拷贝,那么这两个结构体变量没有任何关系

结构体变量也可以将结构体地址赋值给结构体指针变量,这样就成了地址拷贝

package main

import "fmt"

type Person struct {
	name string
	age  int
}

func main() {
	var p1 Person = Person{"张三", 70}
	// 结构体值拷贝
	p2  := p1
	p2.name = "李四"
	fmt.Printf("p1 =>addr = %p,value = %v\n", &p1, p1)
	fmt.Printf("p2 =>addr = %p,value = %v\n", &p2, p2)
	// 结构体地址拷贝
	var p3 *Person = &p2
	// p3的修改,直接影响p2
	p3.name = "王五"
	fmt.Printf("p2 =>addr = %p,value = %v\n", &p2, p2)
	// p3的值就是p2 的地址,当然p3也有自己的内存地址
	fmt.Printf("p3 =>addr = %p,p3 = value = %p\n", &p3, p3)

}


go run main.go
p1 =>addr = 0xc00004a420,value = {张三 70}
p2 =>addr = 0xc00004a440,value = {李四 70}
p2 =>addr = 0xc00004a440,value = {王五 70}
p3 =>addr = 0xc000080020,p3 = value = 0xc00004a440

1.6 匿名结构体

匿名结构体就是没有结构体名称的结构体,无需type关键字就可以直接使用

使用的不多,此处只是提一下

定义格式和初始化写法

ins := struct{
    字段名1 类型1
    字段名2 类型2
    字段名3 类型3
    ...
}{
    字段名1 : 值1,
    字段名2 : 值2,
    字段值3 : 值3,
    ...
}

package main

import "fmt"

func getType(ins struct {
	id   int
	data string
}) {
	fmt.Printf("%T\n", ins)
	ins.id = 99
	fmt.Println(ins)
}
func main() {
	ins := struct {
		id   int
		data string
	}{
		1,
		"hello golang",
	}
	// 将结构体当做值赋给另外一个变量,值拷贝
	ins2 := ins
	ins2.id = 2
	ins2.data = "hello world"
	getType(ins)
	getType(ins2)
	fmt.Println(ins)
	fmt.Printf("%T\n", ins)
}

go run main.go
struct { id int; data string }
{99 hello golang}
struct { id int; data string }
{99 hello world}
{1 hello golang}
struct { id int; data string }

1.7 模拟构造函数

构造函数构造函数
package main

import "fmt"

type Person struct {
	name        string
	nationality string
	BloodType   byte
}

func NewPerson(name string, nationality string, blood byte) *Person {
	return &Person{
		name:        name,
		nationality: nationality,
		BloodType:   blood,
	}
}
func main() {
	p1 := NewPerson("张三", "汉族", 'A')
	fmt.Printf("%s 是 %s 血型是%c型\n", p1.name, p1.nationality, p1.BloodType)
	p2 := NewPerson("李四", "满族", 'B')
	fmt.Printf("%s 是 %s 血型是%c型", p2.name, p2.nationality, p2.BloodType)
}


go run main.go
张三 是 汉族 血型是A型
李四 是 满族 血型是B型