avatar

GO---结构体

GO结构体

定义结构体

1
2
3
4
5
type name struct {
field1 类型
field2 类型
...
}

例:

1
2
3
4
type people struct {
Name,Hobby string
Age int
}

实例化结构体

方法一

1
2
3
4
5
6
7
8
type people struct {
Name,Hobby string
Age int
}
var p people
p.Name = "A"
p.Hobby = "B"
p.Age = 15

方法二

1
2
3
4
5
6
7
8
type people struct {
Name,Hobby string
Age int
}
bob := new(people)
bob.Name = "bob"
bob.Hobby = "baseball"
bob.Age = 15

初始化结构体的成员变量

1.键值对初始化结构体
1
2
3
4
people := 结构体类型名{
字段1:值,
字段2:值,
}

例子:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
type People struct {
name string
child *People
}
relation := &People{
name:"grandfather",
child:&People{
name:"father",
child:&People{
name:"me",
},
},
}
//感觉有点类似于python里的类
2.多个值列表初始化结构体
1
2
3
4
5
6
7
8
9
10
11
12
type Address struct {
Province string
City string
Zip_Code int
Phone_Num string
}
addr := Address{
"浙江",
"杭州",
12345,
"0",
}
3.初始化匿名结构体
1
2
3
4
5
6
7
8
//少用
peopel := struct {
Name string
Age int
}{
Name:"bob",
Age:15,
}
4.模拟构造函数重载
1
2
3
4
5
6
7
8
9
10
11
12
13
14
type Cat struct {
Color string
Name string
}
func New_Cat_Name(name string) *Cat{
return &Cat{
Name:name,
}
}
func New_Cat_Color(color string) *Cat{
return &Cat{
Color:color,
}
}
5.模拟父级构造调用
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
type Cat struct {
Color string
Name string
}
type Black_Cat struct {
Cat
}
//构造基类
func New_Cat(name string) *Cat {
return &Cat {
Name:name,
}
}
//构造子类
func New_Black_Cat(color string) *Black_Cat {
cat := &Black_Cat{}
cat.Color = color
return cat
}

方法

接收器–方法作用的目标

1
2
3
func (接收器 接收器类型) 方法名(参数列表) (返回参数){
函数体
}
1.面向过程实现方法
1
2
3
4
5
6
7
8
9
10
11
type Bag struct {
items []int
}
//(b*Bag)表示接收器
func Insert(b *Bag,itemid int) {
b.items = append(b.items,itemid)
}
fun main(){
bag := new(Bag)
Insert(bag,1001)
}
2.指针类型的接收器
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
//属性结构
type Property struct {
value int
}
//设置属性值
func (p *Property) Set_Value(v int) {
p.value = v
}
//取值
func (p *Property) Value() int {
return p.value
}
func main(){
p := new(Property)
p.Set_Value(100)
fmt.Println(p.Value())
}
3.非指针类型的接收器
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
package main

import "fmt"

type Point struct {
X int
Y int
}

func (p Point) Add(other Point) Point {
return Point{p.X + other.X,p.Y+other.Y}
}
func main() {
p1 := Point{1,1}
p2 := Point{2,2}
result := p1.Add(p2)
fmt.Println(result)
}
4.为类型添加方法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
package main

import (
"fmt"
)

type My_Int int

func (m My_Int) Is_Zero() bool{
return m==0
}

func (m My_Int) Add(other int) int{
return other + int(m)
}

fun main(){
var b My_Int
fmt.Println(b.Is_Zero())
b = 1
fmt.Println(b.Add(2))
}
5.声明结构体内嵌
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package main

imrpot "fmt"

type Basic_Color struct {
R,G,B float32
}
type Color struct {
Basic_Color
Alpha float32
}
func main(){
var c Color
c.R = 1
c.G = 1
c.B = 0
c.Alpha = 1
fmt.Printf("%+v",c)
}
文章作者: jia9yo
文章链接: http://wlaqstcs.com/19999/
版权声明: 本博客所有文章除特别声明外,均采用 CC BY-NC-SA 4.0 许可协议。转载请注明来自 jia9yo-网络安全渗透测试

评论