13-Go语言指针和方法

指针

普通数据类型指针

• Go语言中的普通指针和C语言中的普通指针一样, 通过指针也可以间接操作指向的存储空间
• Go语言中指针的格式 : var p *int

    //1.普通指针
    var num int = 10
    var value float32 = 3.14
    var flag bool = false
    fmt.Println(num,value,flag)//10 3.14 false

    //定义普通指针第一种方法
    //var p1 *int = &num
    //var p2 *float32 = &value
    //var p3 *bool = &flag

    //定义普通指针简写方法
    p1 := &num
    p2 := &value
    p3 := &flag

    //通过指针操作对应存储空间数据
    *p1 = 20
    *p2 = 6.66
    *p3 = true
    fmt.Println(num,value,flag)//20 6.66 true

---

指向数组的指针

• Go语言中指向数组的指针和C语言中指向数组的指针差不多, 通过指针也可以间接操作数组
• Go语言中指向数组指针的格式 var p *[3]int
• Go语言只要一个指针指向数组之后, 就可以通过指针来操作数组
  • 格式 : (*p)[0] / p[0]
• 注意点
  • C语言中数组名/&数组名/&数组首元素 都是同一个地址
    Go语言中&数组名/&数组首元素 都是同一个地址, 但是通过数组名不能直接获取数组的地址
  • 在Go语言中只有相同类型的数据才能赋值
  • 在Go语言中指向数组的指针不支持+1 -1的操作

    //2.数组的指针
    var arr = [3]int{1,3,5}
    //打印地址
    fmt.Printf("%p\n",arr) //%!p([3]int=[1 3 5])
    fmt.Printf("%p\n",&arr) //0xc04200e320
    fmt.Printf("%p\n",&arr[0]) //0xc04200e320

    //打印类型
    fmt.Printf("%T\n", &arr)//*[3]int 数组类型指针
    fmt.Printf("%T\n", &arr[0]) //*int int类型的指针

    //定义数组的指针
    var p *[3]int
    p = &arr
    //p = &arr[0]  不可以的,数据类型不同不能直接赋值

    //通过指针操作数组
    //第一种指针操作数组的写法
    (*p)[0] = 666
    fmt.Println(arr) //[666 3 5]
    //第二种指针操作数组的写法
    p[0] = 888
    fmt.Println(arr) //[888 3 5]

---

指向切片的指针

• 一定要清楚切片的本质是一个结构体, 结构体中的一个属性是指针, 这个指针指向了底层的一个数组
• 注意点:
  • 如果一个指针指向了数组, 那么可以通过 (*p)[0]和p[0]来操作指向的数组
  • 但是如果一个指针指向了切片, 只能通过(*p)[0]来操作指向的切片

    //切片的指针
    var sce []int = []int{1,3,5,7}
    //打印地址
    //切片变量名sce打印的地址得到的是结构体中指向底层数组的指针保存的值
    fmt.Printf("sce = %p\n",sce)//sce = 0xc04200e320
    //&sce打印的地址是该切片自身的存储地址
    fmt.Printf("&sce = %p\n",&sce)//&sce = 0xc042002440

    //打印类型
    fmt.Printf("%T\n", sce) //[]int
    fmt.Printf("%T\n", &sce)//*[]int

    //定义切片指针
    var p *[]int
    p = &sce
    //结论: p == &sce  *p == sce
    fmt.Printf("%p\n", p) //0xc042002440
    fmt.Printf("%p\n", *p) //0xc04200e320

    //使用指针操作切片
    //结论: 指针操作切片的方式只有一种(*切片指针名称)[索引]
    (*p)[0] = 777
    fmt.Println(sce)
    //p[0] = 888  会报错,因为p == &sce,而操作切片需要sce来操作不是&sce
    fmt.Println(sce)

---

指向字典的指针

• 和普通指针一样, 只能通过(*p)[key]来操作字典

    //4.指向字典的指针
    var dict = map[string]string{"name" :"wjh", "age" : "18"}
    //定义字典类型的指针
    var p *map[string]string = &dict
    fmt.Printf("%T\n", p) //*map[string]string
    fmt.Printf("%p\n",dict) //0xc04205c1e0
    fmt.Printf("%p\n",*p) //0xc04205c1e0

    //通过指针操作字典
    (*p)["name"] = "lnj"
    fmt.Println(dict) //map[name:lnj age:18]
    

---

指向结构体的指针

• 和C语言中指向结构体的指针一样, 可以通过(*p).attr和p.attr来操作结构体

//5.结构体类型的指针
    //定义结构体类型
    type Person struct {
        name string
        age int
    }
    //定义结构体变量
    per := Person{"wjh", 10}

    //定义结构体指针变量
    var p *Person
    p = &per
    fmt.Printf("%p\n", p) //0xc042002440
    fmt.Printf("%p\n", &per) //0xc042002440
    //使用指针操作结构体
    //操作结构体的第一种方式
    (*p).name = "zs"
    //操作结构体的第二种方式
    p.age = 30
    fmt.Println(per)

指针作为函数的参数和返回值

• 指针作为函数的参数和C语言一样, 修改形参会影响实参
• 指针作为函数的返回值, 如果指针指向的是一个局部变量, 那么不建议返回
  因为当函数调用完毕局部变量就释放了

---

方法

方法的概念和使用

• Go语言的方法就是一个特殊的函数, 函数是独立存在的, 而方法是和某种数据类型绑定在一起的
• 如何将一个函数和某种数据类型绑定在一起?
  • 如下格式的含义就是将某个函数和接收者类型绑定在一起
    func (接收者名称 接收者类型)函数名称(形参列表)(返回值列表){ 逻辑语句 }
• Go语言中的函数可以和任何类型绑定, 但是一般用于和结构体绑定
• 注意点
  • 方法和函数的区别在于, 函数可以直接调用(通过包名.函数名称), 而方法只能通过绑定的数据类型对应的变量来调用(变量.函数名称)
  • 函数名称和方法名称可以重名

package main

import "fmt"

//1.定义一个结构体
type Person struct {
    name string
    age int
}

//2.定义一个方法和这个结构体绑定
func (Person)say()  {
    fmt.Println("我是一个方法")
}

//3.定义一个方法指定接收者名称
//如果指定了接收者的名称, 那么调用方法时会将调用者传递给接收者
//简单理解: 可以把接收者也看做是函数的一个形参
func (per Person)say()  {
    fmt.Println("name = ", per.name, "age = ", per.age)
}

//4.既然可以把接收者看做是一个形参, 那么就存在值传递和地址传递问题
func (per Person)setName(name string)  {
    per.name = name
}
func (ptr *Person)setAge(age int)  {
    ptr.age = age
}

func main() {
    /*
    1.什么是Go语言的方法?
    Go语言的方法就是一个特殊的函数, 函数是独立存在的, 而方法是和某种数据类型绑定在一起的

    2.如何将一个函数和某种数据类型绑定在一起?
    如下格式的含义就是将某个函数和接收者类型绑定在一起

    func (接收者名称 接收者类型)函数名称(形参列表)(返回值列表){
        逻辑语句
    }

    3.Go语言中的函数可以和任何类型绑定, 但是一般用于和结构体绑定

    注意点:
    1.方法和函数的区别在于, 函数可以直接调用(通过包名.函数名称), 而方法只能通过绑定的数据类型对应的变量来调用(变量.函数名称)
    2.函数名称和方法名称可以重名
    */

    //1.方法只能通过绑定数据类型的变量来调用
    //定义结构体变量
    per := Person{"wjh", 20}
    //通过结构体变量调用方法
    per.say()

    //2.定义方法接收者名称
    p := Person{"wjh", 20}
    //通过结构体变量调用方法
    p.say()

    //3.接收者接收值类型和指针类型
    p := Person{"wjh", 20}
    //值传递类型,不能改变结构体的值
    p.setName("lnj")
    fmt.Println(p) //{wjh 20}
    //地址传递,可以修改结构体属性的值
    var pt *Person = &p
    //调用方法有两种写法
    pt.setAge(70)
    (*pt).setAge(50)

    fmt.Println(p)
}

---

方法和函数的异同

• 方法和函数都是 函数类型
• 函数通过 包名.函数名称() 调用 / 方法通过 变量.方法名称() 调用
• 方法的接收者可以看做是函数的一个形参, 会将调用者传递给接收者
  接收者和函数形参一样, 也区分值传递和地址传递
  到底是值传递还是地址传递, 和函数的形参一样
• 接收者地址传递的两种方式
  (*指针变量名).方法名称()
普通变量名.方法名称()
• 只要接收者是指针类型, 那么编译器就会自动将普通变量的地址取出来传递给接收者

package main

import "fmt"

//1.定义一个结构体
type Person struct {
    name string
    age int
}
//2.定义方法绑定结构体
func (per Person)setName(name string)  {
    per.name = name
}
//3.接收者定义指针类型
func (ptr *Person)setAge(age int)  {
    ptr.age = age
}

//定义一个函数
func test()  {
    fmt.Println("我是一个函数")
}
func (Person)say()  {
    fmt.Println("我是一个方法")
}
func main() {
    /*
    1.方法和函数的异同
    1.1方法和函数都是 函数类型
    1.2函数通过 包名.函数名称() 调用 / 方法通过  变量.方法名称() 调用
    1.3方法的接收者可以看做是函数的一个形参, 会将调用者传递给接收者
       接收者和函数形参一样, 也区分值传递和地址传递
       到底是值传递还是地址传递, 和函数的形参一样
    接收者地址传递的两种方式
    (*指针变量名).方法名称()
    普通变量名.方法名称()
    只要接收者是指针类型, 那么编译器就会自动将普通变量的地址取出来传递给接收者
    */

    //1.定义结构体类型变量
    var per Person= Person{"wjh", 20}
    per.setName("lnj")
    fmt.Println(per)
    //只要接收者是指针类型, 那么编译器就会自动将普通变量的地址取出来传递给接收者
    //接收者虽然是指针类型,但是也可以直接将普通变量传入
    per.setAge(50)
    fmt.Println(per)
    //自己手动定义结构体类型指针变量
    var ptr *Person
    ptr = &per
    (*ptr).setAge(100)
    fmt.Println(per)

    //2.方法和函数都是函数类型
    var per Person= Person{"wjh", 20}
    fmt.Printf("%T\n", test) //func()
    fmt.Printf("%T\n", per.say) //func()

    //既然方法也是函数,函数可以定义变量保存该函数,方法也可以
    //定义一个用于保存没有形参没有返回值的函数类型变量
    var fn = test
    fn()
    fn = per.say
    fn()
}