Golang学习笔记—结构体

结构体

Go语言没有纯粹的面向对象概念，都是使用结构体、函数等来实现。面相对象编程的一些特性，例如：继承、组合等特性

定义

主要是struct关键字，结构如下：

type struct_name struct{
	member defintion
}

type：结构体定义关键字

struct_name：结构体类型名称

struct：结构体定义关键字

member definition：成员定义

结构体的初始化

未初始化时，成员都是零值，int—>0，float—>0，bool—>false，string—>nil

type test struct {
    
   name bool
   id   float32
   sex  string
   age  int
}
var Sentiment test
fmt.Println(Sentiment)

结果：

{false 0  0}

结构体成员声明与赋值

点运算符赋值

Demo01

package main

import "fmt"

func main() {
    
   type test struct {
    
      name string
      id   int
      sex  string
      age  int
   }
   var Sentiment test				//声明
   Sentiment.id = 1					//下面都属于点运算符赋值部分
   Sentiment.name = "Sentiment"
   Sentiment.sex = "man"
   Sentiment.age = 18
   fmt.Println(Sentiment)
}

结果:

{
    Sentiment 1 man 18}

键值对赋值

除此之外还可以通过键值对赋值

package main

import "fmt"

func main() {
    
   type test struct {
    
      name string
      id   int
      sex  string
      age  int
   }
   Sentiment := test{
    
      name: "Sentiment",
      id:   1,
      sex:  "man",
      age:  18,        //注：最后也需要加逗号
   }

   fmt.Println(Sentiment)
}

匿名结构体

如果结构体是临时使用，可以不用起名字，直接使用

demo02

package main

import "fmt"

func main() {
    
   var dog struct {
    
      id   int
      name string
   }
   dog.id = 1
   dog.name = "Tana"
   fmt.Println(dog)
}

结果：

{
    1 Tana}

结构体指针

demo03

结构体指针和普通的变量指针类似

package main

import "fmt"

func main() {
    
   type Person struct {
    
      id   int
      name string
   }
   var Sentiment = Person{
    1, "Sentiment"}
   var p_person = &Sentiment
   fmt.Printf("Sentiment:%v\n", Sentiment)		//输出结构体
   fmt.Printf("p_person:%p\n", p_person)		//结构体地址
   fmt.Printf("p_person:%v", p_person)			//结构体地址对应的值

}

结果：

Sentiment:{
    1 Sentiment}
p_person:0xc000004078
p_person:&{
    1 Sentiment}

new关键字创建结构体指针

除了上述的&赋值创建外，可以通过new关键字对结构体进行实例化，得到的是结构体的地址

package main

import "fmt"

func main() {
   type Person struct {
      id   int
      name string
   }
   var p_person = new(Person)

   fmt.Printf("p_person:%T\n", p_person)

}

结果：

p_person:*main.Person

结构体指针成员赋值

结构体指针成员，也可以用点运算符进行赋值

package main

import "fmt"

func main() {
    
   type Person struct {
    
      id   int
      name string
   }
   var p_person = new(Person)
   p_person.id = 1
   p_person.name = "Sentiment"
   fmt.Printf("p_person:%v", p_person)

}

结果：

p_person:&{
    1 Sentiment}

结构体作为函数参数

结构体也可以像变量一样，作为函数的实参传递给函数，分为两种方式：

• 直接传递结构体：在函数内部不会改变外部结构体的内容(相当于一次调用结构体的值本身不会发生改变)
• 传递结构体指针：在函数内部，能够改变外部结构体的内容(由于使用的是指针，所以是对内存地址进行的操作，结构体发生改变)

直接传递结构体

Demo04

package main

import "fmt"

type Person struct {
    
   name string
   id   int
}

func show(person Person) {
    
   person.id = 1
   person.name = "Sentiment"
   fmt.Println(person)
}
func main() {
    
   person := Person{
    "Tana", 2}
   fmt.Printf("person: %v\n", person)			
   fmt.Println("-------------")
   show(person)								//调用show方法后值发生改变
   fmt.Println("-------------")
   fmt.Printf("person: %v", person)			//但只是进行了一次调用，再次输出person的值，还是不变的
}

结果：

person: {
    Tana 2}
-------------
{
    Sentiment 1}
-------------
person: {
    Tana 2}

传递结构体指针

package main

import "fmt"

type Person struct {
    
	name string
	id   int
}

//func show(person Person) {
    
// person.id = 1
// person.name = "Sentiment"
// fmt.Println(person)
//}
func show2(person *Person) {
    
	person.id = 3
	person.name = "Mumu"
	fmt.Println(person)
}
func main() {
    
	person := Person{
    "Tana", 2}
	fmt.Printf("person: %v\n", person)
	fmt.Println("-------------")
	show2(&person) 								//调用show2方法，获取的形参是指针类型
	fmt.Println("-------------")
	fmt.Printf("person:%v", person) 		//由于是指针类型，取的内存地址，因此调用后外部的结构体值也发生改变
}

结果：

person: {
    Tana 2}
-------------
&{
    Mumu 3}
-------------
person:{
    Mumu 3}

结构体的嵌套

假设一个人Person结构体，这个人还养了一直宠物Dog结构体

Dog结构体

type Dog struct {
    
   name string
   age  int
}

Person1结构体

type Person1 struct {
    
	dog  Dog
	name string
	id   int
}

Demo05

package main

import "fmt"

type Dog struct {
    
   name string
   age  int
}
type Person1 struct {
    
   dog  Dog
   name string
   id   int
}

func main() {
    
   Sentiment := new(Person1)
   Sentiment.id = 1
   Sentiment.name = "Sentiment"
   Sentiment.dog.name = "Tana"
   Sentiment.dog.age = 3
   fmt.Println(Sentiment)
}

结果：

&{
    {
    Tana 3} Sentiment 1}