社区微信群开通啦,扫一扫抢先加入社区官方微信群
社区微信群
结构体(struct)是用户自定义的类型,它代表若干字段的集合。有些时候将多个数据看做一个整体要比单独使用这些数据更有意义,这种情况下就适合使用结构体。
type person struct {//声明一个名为 person 的结构体类型
name string//一个string类型的字段name,用来保存用户名称这个属性
addr string//一个string类型的字段addr,用来保存用户地址这个属性
age int//一个int类型的字段age,用来保存用户年龄这个属性
}
Go语言中,也和C或者其他语言一样,我们可以声明新的类型,作为其它类型的属性或字段的容器。例如,我们可以创建一个自定义类型person代表一个人的实体。这个实体拥有属性:姓名和年龄。这样的类型我们称之struct。
等价于:
type person struct {//声明一个名为 person 的结构体类型
name, addr string
age int
}
我们也可以定义一个没有类型名称的结构体,这种结构体叫做匿名结构体(anonymous structures)。
var person struct {//声明一个名为 person 的结构体类型
name, addr string
age int
}
//定义匿名结构体时没有 type 关键字,与其他定义类型的变量一样,如果在函数外部
//需在结构体变量前加上 var 关键字,在函数内部可省略 var 关键字。
package main
import "fmt"
type Student struct {
id int
name string
sex byte
age int
addr string
}
func main() {
//1、顺序初始化,必须每个成员都初始化
var s1 Student = Student{1, "mike", 'm', 18, "sz"}
s2 := Student{2, "yoyo", 'f', 20, "sz"}
//s3 := Student{2, "tom", 'm', 20} //err, too few values in struct initializer
//2、指定初始化某个成员,没有初始化的成员为零值
s4 := Student{id: 2, name: "lily"}
fmt.Println(s1,s2,s4)
// {1 mike 109 18 sz} {2 yoyo 102 20 sz} {2 lily 0 0 }
}
package main
import "fmt"
type Student struct {
id int
name string
sex byte
age int
addr string
}
func main() {
var s5 *Student = &Student{3, "xiaoming", 'm', 16, "bj"}
s6 := &Student{4, "rocco", 'm', 3, "sh"}
fmt.Println(s5,s6)//&{3 xiaoming 109 16 bj} &{4 rocco 109 3 sh}
}
package main
import "fmt"
type Student struct {
id int
name string
sex byte
age int
addr string
}
func main() {
//===============结构体变量为普通变量
//1、打印成员
var s1 = Student{1, "mike", 'm', 18, "sz"}
//结果:id = 1, name = mike, sex = m, age = 18, addr = sz
fmt.Printf("id = %d, name = %s, sex = %c, age = %d, addr = %sn", s1.id, s1.name, s1.sex, s1.age, s1.addr)
//2、成员变量赋值
var s2 Student
s2.id = 2
s2.name = "yoyo"
s2.sex = 'f'
s2.age = 16
s2.addr = "guangzhou"
fmt.Println(s2) //{2 yoyo 102 16 guangzhou}
}
package main
import "fmt"
type Student struct {
id int
name string
sex byte
age int
addr string
}
func main() {
//===============结构体变量为指针变量
//3、先分配空间,再赋值
s3 := new(Student)
s3.id = 3
s3.name = "xxx"
fmt.Println(s3) //&{3 xxx 0 0 }
//4、普通变量和指针变量类型打印
var s4 Student = Student{4, "yyy", 'm', 18, "sz"}
fmt.Printf("s4 = %v, &s4 = %vn", s4, &s4) //s4 = {4 yyy 109 18 sz}, &s4 = &{4 yyy 109 18 sz}
var p *Student = &s4
//p.成员 和(*p).成员 操作是等价的
p.id = 5
(*p).name = "zzz"
fmt.Println(p, *p, s4) //&{5 zzz 109 18 sz} {5 zzz 109 18 sz} {5 zzz 109 18 sz}
}
如果结构体的全部成员都是可以比较的,那么结构体也是可以比较的,那样的话两个结构体将可以使用 == 或 != 运算符进行比较,但不支持 > 或 < 。
package main
import "fmt"
type Student struct {
id int
name string
sex byte
age int
addr string
}
func main() {
s1 := Student{1, "mike", 'm', 18, "sz"}
s2 := Student{1, "mike", 'm', 18, "sz"}
fmt.Println("s1 == s2", s1 == s2) //s1 == s2 true
fmt.Println("s1 != s2", s1 != s2) //s1 != s2 false
}
package main
import "fmt"
type Student struct {
id int
name string
sex byte
age int
addr string
}
func printStudentValue(tmp Student) {
tmp.id = 250
//printStudentValue tmp = {250 mike 109 18 sz}
fmt.Println("printStudentValue tmp = ", tmp)
}
func main() {
var s Student = Student{1, "mike", 'm', 18, "sz"}
printStudentValue(s)//值传递,形参的修改不会影响到实参
fmt.Println("main s = ", s) //main s = {1 mike 109 18 sz}
}
package main
import "fmt"
type Student struct {
id int
name string
sex byte
age int
addr string
}
func printStudentPointer(p *Student) {
p.id = 250
//printStudentPointer p = &{250 mike 109 18 sz}
fmt.Println("printStudentPointer p = ", p)
}
func main() {
var s Student = Student{1, "mike", 'm', 18, "sz"}
printStudentPointer(&s)//引用(地址)传递,形参的修改会影响到实参
fmt.Println("main s = ", s)//main s = {250 mike 109 18 sz}
}
要使某个符号对其他包(package)可见(即可以访问),需要将该符号定义为以大写字母 开头。
目录结构:
test.go示例代码如下:
//test.go
package test
//student01只能在本文件件引用,因为首字母小写
type student01 struct {
Id int
Name string
}
//Student02可以在任意文件引用,因为首字母大写
type Student02 struct {
Id int
name string
}
main.go示例代码如下:
// main.go
package main
import (
"fmt"
"test" //导入test包
)
func main() {
//s1 := test.student01{1, "mike"} //err, cannot refer to unexported name test.student01
//err, implicit assignment of unexported field 'name' in test.Student02 literal
//s2 := test.Student02{2, "yoyo"}
//fmt.Println(s2)
var s3 test.Student02 //声明变量
s3.Id = 1 //ok
//s3.name = "mike" //err, s3.name undefined (cannot refer to unexported field or method name)
fmt.Println(s3)
}
如果觉得我的文章对您有用,请随意打赏。你的支持将鼓励我继续创作!