GO语言小锤硬磕.十六 指针

普通指针，指针是用来存放其他变量地址的变量。go语言的指针（32位4个字节，64位8个字节）

        通过*来访问指针变量指向的存储空间

package main
import "fmt"
func main(){
//1.普通指针定义
    var p1 *int
    var p2 *float64
    var p3 *bool
    fmt.Println(unsafe.Sizeof(p1),unsafe.Sizeof(p2),unsafe.Sizeof(p3))

//2.通过*来访问指针变量指向的存储空间
    var num int = 666
    var p4 *int = &num   //指针指向变量地址
    fmt.Println(*p4)     //666 通过*访问地址
    *p4 = 888            //修改指针指向变量的值
    fmt.Println(num)    //888变量被修改    

//3.指向数组的指针。
    //go语言只有数据类型完全相同才能赋值，所以只能通过&数组名赋值给指针变量
    var arr = [3]int
    var p5 *[3]int

    //p5 = arr     //报错p5是指针存储地址
    p5 = &arr      //数组的地址
   
    //操作方式
    arr[1] = 6       //直接通过数组名操作
    p5[1] = 6        //通过指针间接操作   p5[1] = &arr[1] 类型是 *int
    (*p5)[1] = 7      //通过指针间接操作
    
    var p6 *[3]int
    //p6 = &arr[0]  报错，类型不同
      
//4.go语言的指针不支持+1，-1，++ --操作
    //*(p + 1) = 9  报错
    //*p++          报错

//5.指向切片的指针（切片本质是一个指针注销哪个数组，指向切片的指针是一个二级指针）
    var sce[]int = []int{1,3,5}    //定义一个切片
    var p7 *[]int                  //定义一个指向切片的指针
    p7=&sce                        //类型一致才能赋值
    fmt.Println(p7)
    fmt.Println(*p7)
    (*p7)[1] = 666                  //修改切片的值 
    fmt.Println(sce[1])            

//6.指向字典的指针
    var dict map[string]string = map[string]string{"name":"xiaoming","age":"33"}
    var p8 *map[string]string = &dict
    (*p8)["name"] = "zs"
    fmt.Println(dict)    

//7.指向结构体的指针
    type Student struct{
        name string
        age int
    }
    //利用取地址符号获取结构体变量地址
    var p9 = &Student{"lnj",33}

    //使用过new内置函数传入数据类型创建
    var p10 = new(Student)

    //操作结构体
    (*p9).name = "lnj" //传统方式
    p9.age = 33         //语法糖 会转为 (*p9).age
    
}

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

        如果指针类型作为函数参数，修改形参会影响实参

        不能将函数内的指向局部变量的指针作为返回值，函数结束指向空间会被释放

        可以将函数内部的局部变量作为返回值，本质是拷贝一份

        go语言的方法其实就是一个特殊的函数，只不过这个函数是和某种属性类似绑定在一起而已

        go语言中的方法一般用于将函数和结构体绑定在一起，让结构体除了能够保存数据外，还能够具备某些行为

        将函数和数据类型绑定的格式

        只需要在函数名称前面加上（接受者  数据类型）即可将函数和某种数据类型绑定一起

func( 接收者 数据类型)  方法名称 （形参列表）(返回值列表){

        方法体

}

package main
import "fmt"
//1.定义一个结构体
type Person struct{
    name string 
    age int
}
//2.定义一个函数 ，并将这个函数和Person结构体绑定在一起
func (p Person)say(){
    fmt.Println("my name is",p.name,"my age is",p.age)
}

fucn main(){
//3.创建一个结构体变量
    per:= Person{"lnj",33}
    //调用是会自动调用者(per)传递个方法的接收者(p)
    per.say()
}

方法与函数的异同

        方法的数据类型也是函数类型，所以可以定义变量保存(作为参数返回值等)

package main
import "fmt"
type Person struct{
    name string
    age int
}
//定义一个方法
func (p Person)say(){
    fmt.Println("say方法")
}

//定义一个函数
func say(){
    fmt.Println("say")
}
 
//接收者是一个变量
func (p Person)setName(name string){
    P.name = name
}
//接收者是一个指针
func (p *Person)setAge(age int){
    p.age = age
}


func main(){
    p := Person{"xiaomeng",33}
    fmt.Printf("%T\n",p.say())
//定义一个保存没有形参没有返回值的函数类型变量
    var fn func()
//利用函数类型变量保存一个方法
    fn = p.say()
//利用函数类型变量调用一个方法
    fn()
//利用函数类型变量保存一个函数
    fn=say
//利用函数类型变量调用一个函数
    fn()

//方法只能通过绑定类型的变量调用，函数可以直接调用
    say() //函数的调用
    p.say() //方法的调用


//方法的接收者可以看做是函数的一个形参（值传递和地址传递）
    per :=Person("xx",33)
    per.setName("zs")      //值传递修改不会影响外部的值    func (p Person)
    fmt.Println(per)       //{xx 33}

    p := &per  
    (*p).setAge(44)       //地址传递，方法内部修改会影响方法外部     
    fmt.Println(per)      //{xx 44}  

//地址传递的几种调用方式
    per1 := Person{"lnj",33}
    p1 := &per1         //一、拿到指针
    (*p1).setAge(18)    //通过指针调用
    per1.setAge（66）   //二、直接利用变量调用，底层会自动获取变量地址传递给接收者 (p *Person)
    fmt.Println(per1)

    

}