【Golang】结构体详解

于 2023-10-26 14:23:54 发布
阅读量1.4k 收藏 9
点赞数 2
文章标签： golang linux 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Suk_god/article/details/133877517
版权

文章目录

1、类型别名 && 自定义类型

Go语言中没有 “类” 的概念，也不支持 “类” 的继承等面向对象的概念
Go语言中通过结构体的内嵌 再配合 接口，达到比面向对象更高的扩展性和灵活性

1.1、自定义类型

在Go语言中有一些基本的数据类型，可以使用type关键字来定义自定义类型
自定义类型是定义了一个全新的类型，我们可以基于内置的基本类型定义，也可以通过struct定义

type MyInt int
type MyStruct struct {
	Name string
	Age  int
}

通过type关键字的定义，MyInt && MyStruct 就是一种新的类型

1.2、 类型别名

类型别名规定：TypeAlias只是Type的别名，本质上TypeAlias与Type是同一个类型

type TypeAlias = Type
//e.g
type byte = uint8
type rune = int32

1.3、二者的区别

类型别名与类型定义表面上看只有一个等号的差异，我们通过下面的这段代码来理解它们之间的区别

//类型定义
type NewInt int

//类型别名
type MyInt = int

func main() {
	var a NewInt
	var b MyInt
	
	fmt.Printf("type of a:%T\n", a) 
	fmt.Printf("type of b:%T\n", b)
}

在这里插入图片描述
结果显示a的类型是main.NewInt，表示main包下定义的NewInt类型
b的类型是int。MyInt类型只会在代码中存在，编译完成时并不会有MyInt类型

总结：类型定义有新类型产生，类型别名没有新类型产生，并且在编译阶段被替换为原始类型

2、结构体

Go语言中的基础数据类型可以表示一些事物的基本属性，但是当我们想表达一个事物的全部或部分属性时，这时候再用单一的基本数据类型明显就无法满足需求了

Go语言提供了一种自定义数据类型，可以封装多个基本数据类型 or 自定义类型，这种数据类型叫结构体，英文名称struct

2.1、结构体定义

使用type和struct关键字来定义结构体，具体代码格式如下：

type 类型名 struct {
    字段名 字段类型
    字段名 字段类型
    …
}

注意：

  • 类型名：表示自定义结构体的名称，同一个包内不允许重复
  • 字段名：表示结构体字段的名称，在整个结构体内这个名称是唯一的
  • 字段类型：表示结构体字段的具体类型，可以是基本数据类型，也可以是自定义类型

e.g:

type Person struct {
	Name string
	City string
	Age  int
}

上面代码表示：定义了一个自定义类型Person,由Name, City，Age三个字段组成

语言内置的基础数据类型是用来描述一个值的，而结构体是用来描述一组值的，本质上是一种聚合型的数据类型

2.2、结构体实例化

只有当结构体实例化的时候，才会真正的分配内存，也就是 必须实例化后才能使用结构体中的字段

结构体本身也是一种类型，我们可以像申明内置类型那样申明一个结构体

var 结构体实例  结构体类型

下面介绍结构体实例化的几种方式：

  • 基本实例化
type Person struct {
	Name string
	City string
	Age  int
}

func main() {
	var person Person
	person.Name = "GGBond"
	person.Age = 18
	person.City = "深圳"

	fmt.Println(person)
	fmt.Printf("%+v\n", person)
	fmt.Printf("%#v\n", person)
}

在这里插入图片描述

  • 匿名结构体
    在定义一些临时数据结构等场景下还可以使用匿名结构体
func main() {
	var person struct {
		Name string
		Age  int
		City string
	}
	person.Name = "GGBond"
	person.Age = 18
	person.City = "深圳"

	fmt.Printf("%+v\n", person)
}

在这里插入图片描述

  • 创建指针类型结构体
    我们还可以通过使用new关键字对结构体进行实例化，得到的是结构体的地址。 格式如下：
type Person struct {
	Name string
	Age  int
	City string
}

func main() {
	var p2 = new(Person)
	fmt.Printf("%T\n", p2)
	fmt.Printf("p2=%+v\n", p2)
}

在这里插入图片描述
可以看到：结构体成员变量没有显示赋值的，均是对应类型的0值
同时这里的p2是一个结构体指针
我们可以使用指针的基本操作来对这个new出来的结构体变量的成员进行赋值操作：

func main() {
	var p2 = new(Person)
	fmt.Printf("%T\n", p2)
	fmt.Printf("p2=%+v\n", p2)

	//使用指针的操作方式对Person成员进行赋值
	(*p2).Name = "GGBond"
	p2.Age = 18
	p2.City = "深圳"

	fmt.Printf("p2=%+v\n", p2)
}

在这里插入图片描述
注意：
 在Go语言中支持对结构体指针直接使用 .来访问结构体的成员
 不支持像C/C++ 使用 ->的方式访问

  • 取结构体的地址实例化
    使用&对结构体进行取地址操作相当于对该结构体类型进行了一次new实例化操作
type Person struct {
	Name string
	Age  int
	City string
}

func main() {
	var p2 = &Person{}
	
	fmt.Printf("%T\n", p2)
	fmt.Printf("p2=%+v\n", p2)

	//使用指针的操作方式对Person成员进行赋值
	(*p2).Name = "GGBond"
	p2.Age = 18
	p2.City = "深圳"

	fmt.Printf("p2=%+v\n", p2)
}

在这里插入图片描述

2.3、结构体初始化

没有初始化的结构体，其成员变量都是对应其类型的零值
常见的结构体初始化方式有以下几种：

  • 使用键值对初始化
    使用键值对对结构体进行初始化时，键对应结构体的字段，值对应该字段的初始值
type Person struct {
	Name string
	Age  int
	City string
}

func main() {
	person := Person{
		Name: "GGBond",
		Age:  18,
		City: "深圳",
	}
	fmt.Printf("person = %+v\n", person)
}

在这里插入图片描述
当某些字段没有初始值的时候，该字段可以不写。此时，没有指定初始值的字段的值就是该字段类型的零值

  • 使用值得列表初始化
    初始化结构体的时候可以简写，也就是初始化的时候不写键，直接写值：
type Person struct {
	Name string
	Age  int
	City string
}

func main() {
	person := &Person{
		"GGBond",
		18,
		"深圳",
	}
	fmt.Printf("person = %#v\n", person)
}

在这里插入图片描述
使用这种格式初始化时，需要注意：
  必须初始化结构体的所有字段
  初始值的填充顺序必须与字段在结构体中的声明顺序一致
  该方式不能和键值初始化方式混用

2.4、结构体内存布局

结构体占用一块连续的内存空间

type test struct {
	a int8
	b int8
	c int8
	d int8
}


func main() {
	n := test{
		1, 2, 3, 4,
	}
	fmt.Printf("n.a %p\n", &n.a)
	fmt.Printf("n.b %p\n", &n.b)
	fmt.Printf("n.c %p\n", &n.c)
	fmt.Printf("n.d %p\n", &n.d)
}

输出结果：
在这里插入图片描述
再来看另外一个例子：

type Bar struct {
	x int32 // 4
	y *int  // 8
	z bool  // 1
}

func main() {
	var b1 Bar
	fmt.Println(unsafe.Sizeof(b1)) // 24
}

在这里插入图片描述
疑问1：既然结构体的内存是“连续”的，为什么结构体大小不是13（4 + 8 + 1）而是24呢？

接着再来看另一个场景：

type Bar struct {
	y *int  // 8
	x int32 // 4
	z bool  // 1
}

func main() {
	var b1 Bar
	fmt.Println(unsafe.Sizeof(b1)) // 24
}

在这里插入图片描述
疑问2：为什么看似“一样”的代码，就是结构体成员变量的定义顺序不一样，得到的结构体大小却不一样了？

好，想要解决这两个问题，那就得说说结构体中最常见的知识：结构体内存对齐

Go 在编译的时候会按照一定的规则自动进行内存对齐。之所以这么设计是为了减少 CPU 访问内存的次数，加大 CPU 访问内存的吞吐量。如果不进行内存对齐的话，很可能就会增加CPU访问内存的次数

针对上面提到的两个问题，我们可以通过内存对齐的角度来分析

type Bar struct {
	x int32 // 4
	y *int  // 8
	z bool  // 1
}

这个结构体对应的内存示意图如下所示：
在这里插入图片描述
对于另一个结构体，他的内存示意图又是另一种情况

type Bar struct {
	y *int  // 8
	x int32 // 4
	z bool  // 1
}

在这里插入图片描述
我们可以看到，结构体成员变量的定义位置不一样，同一对其规则下就会产生不同大小的结构体。具体的对齐规则参考：
结构体详解
内存对齐-李文周

空结构体是不占用内存空间的

var v struct{}
fmt.Println(unsafe.Sizeof(v))  // 0

由于空结构体struct{}的大小为 0，所以当一个结构体中包含空结构体类型的字段时，通常不需要进行内存对齐。例如：

type Demo1 struct {
	m struct{} // 0
	n int8     // 1
}

var d1 Demo1
fmt.Println(unsafe.Sizeof(d1))  // 1

但是当空结构体类型作为结构体的最后一个字段时，如果有指向该字段的指针，那么就会返回该结构体之外的地址。为了避免内存泄露会额外进行一次内存对齐

type Demo2 struct {
	n int8     // 1
	m struct{} // 0
}

var d2 Demo2
fmt.Println(unsafe.Sizeof(d2))  // 2

2.5、方法和接收者

Go语言中的方法是一种作用于特定类型变量的函数，这种特定类型变量叫做 接收者。接收者的概念就类似于其他语言中的this/self

方法的定义格式如下：

func (接收者变量 接收者类型) 方法名(参数列表) (返回参数) {
    函数体
}

详细解释：

  • 接收者变量：接收者中的参数变量在命名的时候，官方建议使用接收者类型名称首字母的小写，而不是使用self、this这类的命名。例如，Person类型的接收者变量应该命名为p
  • 接收者类型：接收者类型和参数相似，可以是指针类型和非指针类型
  • 方法名、参数列表、返回参数：具体格式与函数定义相同

e.g

type Person struct {
	Name string
	Age  int8
}

func newPerson(name string, age int8) *Person {
	return &Person{
		Name: name,
		Age:  age,
	}
}

func (p Person) Freedom() {
	fmt.Printf("%v 向往自由\n", p.Name)
}

func main() {
	ggbond := newPerson("GGBond", 18)
	ggbond.Freedom()
}

在这里插入图片描述

方法与函数的区别是，函数不属于任何类型，方法属于特定的类型

问：指针类型的 接收者和值类型的接收者有什么区别？应该如何选择？

  • 值类型接收者
    当方法作用于值类型的接收者时，Go语言会在代码运行时将接收者的值复制一份。在值类型接收者的方法中可以获得接收者的成员值，但修改的内容只是针对复制的副本，无法修改接收者变量本身。
  • 指针类型接收者
    指针类型的接收者由一个结构体的指针组成，由于指针的特性，调用方法时修改接收者指针的任意成员变量，在方法结束后，修改都是有效的。这种方式就十分接近于其他语言中面向对象中的this或者self

什么时候该用指针接收者类型呢？

  • 1.需要修改接收者中的值
  • 2.接收者时拷贝代价比较大的对象
  • 3.保证一致性，如果有某个方法使用了指针接收者，那么其他的方法也应该使用指针接收者

2.6、任意类型添加方法

在Go语言中，接收者的类型可以是任何类型，不仅仅是结构体，任何类型都可以拥有方法。
举个例子，我们基于内置的int类型使用type关键字可以定义新的自定义类型，然后为我们的自定义类型添加方法

//MyInt 将int定义为自定义MyInt类型
type MyInt int

//SayHello 为MyInt添加一个SayHello的方法
func (m MyInt) SayHello() {
	fmt.Println("Hello, 我是一个int。")
}
func main() {
	var m1 MyInt
	m1.SayHello() //Hello, 我是一个int。
	m1 = 100
	fmt.Printf("%#v  %T\n", m1, m1) //100  main.MyInt
}

注意事项： 非本地类型不能定义方法，也就是说我们不能给别的包的类型定义方法

2.7、结构体匿名字段

结构体允许其成员字段在申明的时候没有字段名只有字段类型，这种没有名字的字段就称为匿名字段

type Person struct {
	string
	int
}

func main() {
	person := Person{
		"GGBond",
		18,
	}

	fmt.Printf("%#v\n", person)
	fmt.Printf("person.string is : %v, person.int is : %v\n", person.string, person.int)
}

在这里插入图片描述
注意：

  • 这里的匿名字段说法并不是说没有字段名，而是默认会采用类型名作为字段名
  • 结构体要求字段名唯一，因此一个结构体中同种类型的匿名字段只能有一个

2.8、嵌套结构体

一个结构体中可以嵌套包含另一个结构体或结构体指针。示例如下：

type Address struct {
	Province string
	City     string
}

type Person struct {
	Name    string
	Age     int8
	Address Address
}

func main() {
	person := Person{
		Name: "GGBond",
		Age:  18,
		Address: Address{
			Province: "广东",
			City:     "深圳",
		},
	}

	fmt.Printf("%#v\n", person)
}

在这里插入图片描述
当然，也支持 嵌套匿名字段，将上述的Person结构体中的Address字段设置为匿名字段

type Address struct {
	Province string
	City     string
}

type Person struct {
	Name    string
	Age     int8
	Address //匿名字段
}

func main() {
	person := Person{
		Name: "GGBond",
		Age:  18,
		Address: Address{
			Province: "广东",
			City:     "深圳",
		},
	}

	fmt.Printf("%#v\n", person)

	person.Address.Province = "陕西" //匿名字段默认使用类型名作为字段名
	person.City = "西安"             //匿名字段可以直接省略
	fmt.Printf("%#v\n", person)
}

在这里插入图片描述
当访问结构体成员时会先在结构体中查找该字段，找不到再去嵌套的匿名字段中查找

  • 嵌套结构体的字段名冲突
    嵌套结构体内部可能存在相同的字段名。在这种情况下为了避免歧义需要通过指定具体的内嵌结构体字段名。
type Address struct {
	Province   string
	City       string
	CreateTime string
}

type Email struct {
	Account    string
	CreateTime string
}

type Person struct {
	Name    string
	Age     int8
	Address //匿名字段
	Email
}

func main() {
	person := Person{
		Name: "GGBond",
		Age:  18,
		Address: Address{
			Province: "广东",
			City:     "深圳",
		},
	}

	fmt.Printf("%#v\n", person)

	person.Address.Province = "陕西" //匿名字段默认使用类型名作为字段名
	person.City = "西安"             //匿名字段可以直接省略
	//person.CreateTime = "xxxx"  //错误写法，会产生歧义
	person.Address.CreateTime = "xxx"
	person.Email.CreateTime = "111"

	fmt.Printf("%#v\n", person)
}

在这里插入图片描述

2.9、结构体的“继承”

Go语言中使用结构体也可以实现其他编程语言中面向对象的继承

//Animal 动物
type Animal struct {
	name string
}

func (a *Animal) move() {
	fmt.Printf("%s会动！\n", a.name)
}

//Dog 狗
type Dog struct {
	Feet    int8
	*Animal //通过嵌套匿名结构体实现继承
}

func (d *Dog) wang() {
	fmt.Printf("%s会汪汪汪~\n", d.name)
}

func main() {
	d1 := &Dog{
		Feet: 4,
		Animal: &Animal{ //注意嵌套的是结构体指针
			name: "乐乐",
		},
	}
	d1.wang() //乐乐会汪汪汪~
	d1.move() //乐乐会动！
}

2.10、结构体与JSON序列化

JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式。易于人阅读和编写。同时也易于机器解析和生成。JSON键值对是用来保存JS对象的一种方式，键/值对组合中的键名写在前面并用双引号""包裹，使用冒号:分隔，然后紧接着值；多个键值之间使用英文,分隔

// Student 学生
type Student struct {
	ID     int
	Gender string
	Name   string
}

// Class 班级
type Class struct {
	Title    string
	Students []*Student
}

func main() {
	c := &Class{
		Title:    "101",
		Students: make([]*Student, 0, 200),
	}
	for i := 0; i < 5; i++ {
		stu := &Student{
			Name:   fmt.Sprintf("stu%02d", i),
			Gender: "男",
			ID:     i,
		}
		c.Students = append(c.Students, stu)
	}
	//JSON序列化：结构体-->JSON格式的字符串
	data, err := json.Marshal(c)
	if err != nil {
		fmt.Println("json marshal failed")
		return
	}
	fmt.Printf("json:%s\n", data)
	//JSON反序列化：JSON格式的字符串-->结构体
	str := `{
		"Title":"101",
		"Students":[
			{
				"ID":0,
				"Gender":"男",
				"Name":"stu00"
			},
			{
				"ID":1,
				"Gender":"男",
				"Name":"stu01"
			},
			{
				"ID":2,
				"Gender":"男",
				"Name":"stu02"
			},
			{
				"ID":3,
				"Gender":"男",
				"Name":"stu03"
			},
			{
				"ID":4,
				"Gender":"男",
				"Name":"stu04"
			},
			{
				"ID":5,
				"Gender":"男",
				"Name":"stu05"
			}
		]
	}`
	c1 := &Class{}
	err = json.Unmarshal([]byte(str), c1)
	if err != nil {
		fmt.Println("json unmarshal failed!")
		return
	}
	fmt.Printf("%#v\n", c1)
}

2.11、结构体标签（Tag）

Tag是结构体的元信息，可以在运行的时候通过反射的机制读取出来。
Tag在结构体字段的后方定义，由一对反引号包裹起来，具体的格式如下：
key1:"value1" key2:"value2"

结构体tag由一个或多个键值对组成。
键与值使用冒号分隔，值用双引号括起来。
同一个结构体字段可以设置多个键值对tag，不同的键值对之间使用空格分隔。

注意事项：
 为结构体编写Tag时，必须严格遵守键值对的规则。
 结构体标签的解析代码的容错能力很差，一旦格式写错，编译和运行时都不会提示任何错误，通过反射也无法正确取值。

例如我们为Student结构体的每个字段定义json序列化时使用的Tag：

//Student 学生
type Student struct {
	ID     int    `json:"id"` //通过指定tag实现json序列化该字段时的key
	Gender string //json序列化是默认使用字段名作为key
	name   string //私有不能被json包访问
}

func main() {
	s1 := Student{
		ID:     1,
		Gender: "男",
		name:   "GGBond",
	}
	data, err := json.Marshal(s1)
	if err != nil {
		fmt.Println("json marshal failed!")
		return
	}
	fmt.Printf("json str:%s\n", data) //json str:{"id":1,"Gender":"男"}
}

2.12、补充说明

因为slice和map这两种数据类型都包含了指向底层数据的指针，因此我们在需要复制它们时要特别注意。我们来看下面的例子：

type Person struct {
	name   string
	age    int8
	dreams []string
}

func (p *Person) SetDreams(dreams []string) {
	p.dreams = dreams
}

func main() {
	p1 := Person{name: "GGbond", age: 18}
	data := []string{"吃饭", "睡觉", "打豆豆"}
	p1.SetDreams(data)

	// 你真的想要修改 p1.dreams 吗？
	data[1] = "不睡觉"
	fmt.Println(p1.dreams) // ?
}

在这里插入图片描述
针对这种情况，我们需要避免结构体字段与切片共用底层数组
所以，SetDreams的实现方式需要加以修改：

func (p *Person) SetDreams(dreams []string) {
	p.dreams = make([]string, len(dreams))
	copy(p.dreams, dreams)
}

这样修改之后就不会存在上面的情况了

Suk-god
关注
  • 2
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
golang协程池设计详解
09-18
首先，定义一个`SimplePool`结构体，包含一个`sync.WaitGroup`用于同步等待所有工作协程完成，以及一个`work`通道作为任务队列。`NewSimplePoll`函数初始化协程池，根据传入的并发量（workers）启动相应数量的工作...
Golang深入浅出之-Go语言结构体（struct）入门：定义与使用
最新发布
zevjay的博客
04-25 867
Age intAddress Address // 内嵌结构体Zip string上述代码定义了一个名为Person的结构体，包含Name（字符串类型）、Age（整型）两个字段，以及内嵌的Address结构体。结构体的定义简洁明了，字段间以逗号分隔，类型紧跟字段名。常见问题与避免方法问题1：未初始化的结构体字段默认值Go语言结构体的字段如果没有显式初始化，其默认值取决于字段类型。对于数值类型，如intfloat64等，默认为零值；对于字符串类型，默认为空字符串；
十、Go语言中的结构体详解
阿澈不吃蒜的博客
07-28 2150
在 Go 语言中有一些基本的数据类型，如 string、整型、浮点型、布尔等数据类型， Go 语言中可以使用 type 关键字来定义自定义类型。
Golang 结构体
weixin_47243236的博客
12-19 2498
1. 结构体 Golang 也支持面向对象编程（OOP），但其并不是纯粹的面对对象，可以说是 Golang 支持面对对象编程。Golang 中没有类（class）的概念，Golang 中提供了结构体（struct）的概念用于实现 OOP 特性。 Golang 的面对对象编程十分简洁，去除了传统 OOP 的方法重载、构造函数、隐式的 this 指针等。Golang 具有封装、继承、多态的特性，实现方式与其他的 OOP语言不同，比如继承没有 extends 关键字，而是通过匿名类字段实现等。 1.1 定义结构体
golang中结构体
LeoHan
05-02 1552
golang其实并不是一个完全意义上的面向对象语言，其实现面向对象的多态主要基于接口和结构体实现。 在golang中结构体与c/c++中的结构体类似，用来定义复杂的数据类型，一般结构体定义如下： type StructName struct{ fieldName1 type1 fidldName2 type2 ... } 需要注意的是： 结构体的包名在同一个包内必须唯一，不能重复 结构体的字段必须唯一，不能重复 同类型的结构体字段可以放在一行定义 一般结构体实例化可以通过如下方
Go语言实例化结构体——为结构体分配内存并初始化
anlz729的博客
07-26 771
结构体的定义只是一种内存布局的描述，只有当结构体实例化时，才会真正地分配内存。因此必须在定义结构体并实例化后才能使用结构体的字段。 实例化就是根据结构体定义的格式创建一份与格式一致的内存区域，结构体实例与实例间的内存是完全独立的。Go语言可以通过多种方式实例化结构体，根据实际需要可以选用不同的写法。 基本的实例化形式 结构体本身是一种类型，可以像整型、字符串等类型一样，以 var 的方式声明结...
Go 结构体(struct)
weixin_40123451的博客
12-17 1647
go语言中的结构体： Go 结构体与初始化 - Helldorado - 博客园Go 通过类型别名（alias types）和结构体的形式支持用户自定义类型。 结构体是复合类型，当需要定义类型，它由一系列属性组成，每个属性都有自己的类型和值的时候，就应该使用结构体，它把数据聚集在https://www.cnblogs.com/liyutian/p/10050320.html ...
详解Golang 推荐的命名规范
09-19
在Golang中，结构体方法的接收者（receiver）命名也很关键。接收者名称应简洁明了，避免使用像`this`或`super`这样的关键字，比如`type A struct{}`和它的方法`methodA`和`methodB`。 最后，关于注释，Golang推荐...
详解golang避免循环import问题(“import cycle not allowed”)
09-20
在Golang中，循环import（import cycle）是一个常见的编译错误，它发生在两个或多个包之间形成一个相互依赖的环状引用。这种错误通常源于不合理的包设计或接口定义，导致包之间的耦合度过高。当编译器检测到import ...
Golang中的路由使用详解
01-03
之前有篇文章比较浅显的分析了一下golang的服务器如何实现，还有Handler, ...创建路由结构体 type CopyRouter struct { router map[string]map[string]http.HandlerFunc } 在这里我们创建了一个像Default
详解Golang中下划线的使用方法
09-19
在 Golang 中，下划线（_）是一个特殊标识符，具有多种用途。本文将详细介绍其在不同场景下的使用方法。 首先，下划线在导入包时发挥作用。当我们需要导入一个包来执行初始化操作，但并不直接使用包内的具体功能时...
Go语言结构体
书香水墨
07-08 2745
一、结构体 结构体解释:将一个或多个变量组合到一起,形成新的类型.这个类型就是结构体 Go语言中的结构体和C++结构体有点类似,而Java或C#中类本质就是结构体 结构体是值类型 结构体定义语法 通过语法可以看出,Go语言发明者明确认为结构体就是一种自定义类型 type 结构体名称 struct{ 名称 类型//成员或属性 } 定义结构体 结构体可以定义在函数内部或函数外部(与普通变量一样),定义位置影响到结构体的访问范围 如果结构体定义在函数外面,结构体名称首字母是否大
[Go语言入门] 12 Go语言结构体(struct)详解
时空旅客的专栏
07-11 2791
Go语言入门, Go语言结构体
Golang笔记——结构体
weixin_44023658的博客
08-04 732
结构体 看一个问题 使用现有技术解决 单独的定义变量解决 代码演示： 使用数组解决 现有技术解决的缺点分析 使用变量或者数组来解决养猫的问题，不利于数据的管理和维护。因为名字，年龄，颜色都是 属于一只猫，但是这里是分开保存。 如果我们希望对一只猫的属性（名字、年龄，颜色）进行操作(绑定方法)， 也不好处理。 引出我们要讲解的技术-》结构体。 一个程序就是一个世界，有很多对象(变量) Golang 语言面向对象编程说明 Golang 也支持面向对象编程(OOP)，但是和传统的面向对象
Go语言结构体（struct）
技术宅拯救世界
09-02 1252
Go语言可以通过自定义的方式形成新的类型，结构体就是这些类型中的一种复合类型，结构体是由零个或多个任意类型的值聚合成的实体，每个值都可以称为结构体的成员。字段拥有自己的类型和值；字段名必须唯一；字段的类型也可以是结构体，甚至是字段所在结构体的类型。使用关键字 type可以将各种基本类型定义为自定义类型，基本类型包括整型、字符串、布尔等。结构体是一种复合的基本类型，通过 type 定义为自定义类型后，使结构体更便于使用。type 类型名 struct {字段 1 字段 1 类型。
go结构体嵌套
大道至简，持之以恒！
04-15 4277
一个结构体中可以嵌套包含另一个结构体或结构体指针。 //Address 地址结构体 type Address struct { Province string City string } //User 用户结构体 type User struct { Name string Gender string Address Address } func main() { //直接实例化该嵌套结构体 user1 := User
go的结构体嵌套（组合式继承）
qq_43687652的博客
11-09 1942
这个例子中的 ShowB() 就是同名方法。
GO语言中的结构体详解
金戈鐡馬
11-18 983
如果结构体的全部成员都是可以比较的，那么结构体也是可以比较的，那样的话两个结构体将可以使用 == 或!有时我们需要将不同类型的数据组合成一个有机的整体，如：一个学生有学号/姓名/性别/年龄/地址等属性。传参过程中，实参会将自己的值拷贝一份给形参。近乎100%的使用都采用“传址”的方式，将结构体的。结构体是一种聚合的数据类型，它是由一系列具有相同类型或不同类型的数据构成的数据集合。每个数据称为结构体的成员。在Go语言中，普通结构体变量 和 结构体指针变量发访问成员的方法一致。
golang 结构体初始化
08-26
在Go语言中，结构体的初始化可以通过以下几种方法来完成。首先，可以使用键值对的方式来初始化结构体的成员变量。例如，定义一个名为cat的结构体，包含name、age和sex三个成员变量，可以通过以下方式进行初始化： cat1 := cat{ name: "小白", age: 12, sex: "male", } 另一种初始化结构体的方法是使用多个值的列表来初始化结构体的成员变量。例如，可以按照结构体定义的顺序依次传入相应的值进行初始化： cat1 := cat{"小白", 12, "male"} 还可以使用指针类型的结构体进行初始化。例如，定义一个指向cat结构体的指针类型变量，可以通过以下方式进行初始化： cat1 := &cat{ name: "小白", age: 12, sex: "male", } 最后，还可以使用匿名结构体进行初始化。匿名结构体没有定义结构体类型名，直接使用花括号{}进行初始化。例如： cat1 := struct { name string age int sex string }{ name: "小白", age: 12, sex: "male", } 这些是几种常见的初始化结构体的方法，根据实际情况选择适合的方式进行初始化即可。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* *2* [Go语言结构体如何进行初始化](https://blog.csdn.net/weixin_52723461/article/details/124819621)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_1"}}] [.reference_item style="max-width: 50%"] - *3* [Golang结构体和map](https://download.csdn.net/download/weixin_38731199/14037169)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_1"}}] [.reference_item style="max-width: 50%"] [ .reference_list ]

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Suk-god

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值