Go 学习笔记06.指针、结构体、方法、接口

2023-05-22 08:50 47阅读 0赞

## 指针 ##

如果i是变量，通过 `&i` 语法来取得 `i` 的内存地址

如果i是指针，通过`*i` 语法来取得 `i`的值

package main
    
    import "fmt"
    
    
    // 一个函数，接收的是数据类型
    // 一个函数，接收的是数据类型的指针
    // 接收到参数后，将参数值重新赋值，在从外面调用
    // 发现普通的不会改变值，因为在不同的作用域内
    // 而传递指针的，会改变值，因为操作的是内存地址
    func zeroval(ival int) { 
        ival = 0
    }
    
    func zeroptr(iptr *int) { 
        *iptr = 0
    }
    
    
    func main() { 
        i := 1
        fmt.Println("initial:", i)
    
        zeroval(i)
        fmt.Println("zeroval:", i)
    
        zeroptr(&i)
        fmt.Println("zeroptr:", i)
        // 打印指针
        fmt.Println("pointer:", &i)
    }

## 结构体 ##

这篇教程不错

https://www.cnblogs.com/haiguixiansheng/p/10613754.html

package main
    
    import "fmt"
    
    // 这里的 `person` 结构体包含了 `name` 和 `age` 两个字段。
    type person struct { 
        name string
        age  int
    }
    
    func main() { 
    
        // 使用这个语法创建了一个新的结构体元素。
        fmt.Println(person{ "Bob", 20})
    
        // 你可以在初始化一个结构体元素时指定字段名字。
        fmt.Println(person{ name: "Alice", age: 30})
    
        // 省略的字段将被初始化为零值。
        fmt.Println(person{ name: "Fred"})
    
        // `&` 前缀生成一个结构体指针。
        fmt.Println(&person{ name: "Ann", age: 40})
    
        // 使用点来访问结构体字段。
        s := person{ name: "Sean", age: 50}
        fmt.Println(s.name)
    
        // 也可以对结构体指针使用`.` - 指针会被自动解引用。
        sp := &s
        fmt.Println(sp.age)
    
        // 结构体是可变的。
        sp.age = 51
        fmt.Println(sp.age)
    }

## 方法 ##

可以把结构体想象成一个类，这个方法区别于函数，属于类的函数 叫方法。

package main
    
    import "fmt"
    
    // 定义结构体
    type rect struct { 
        width int
        height int
    }
    
    // 定义结构体的方法 面积
    // 方法名叫area,返回值为int
    // 这个接收的是一个指针
    func (r *rect) area() int { 
        return r.width * r.height
    }
    
    // 这个接收的是值，会有数据拷贝，其方法内的操作不会影响外面
    func (r rect) perim() int { 
        return 2*r.width + 2*r.height
    }
    
    func main() { 
        r := rect{ width: 10, height: 5}
    
        fmt.Println("area: ", r.area())
        fmt.Println("perim:", r.perim())
    	
        rp := &r
        fmt.Println("area: ", rp.area())
        fmt.Println("perim:", rp.perim())
    }

area:  50
    perim: 30
    area:  50
    perim: 30

**值类型的变量和指针类型的变量 区别**

https://www.cnblogs.com/zlingh/p/5701785.html

## 接口 ##

package main
    
    import "fmt"
    import "math"
    
    // 这里是一个几何体的基本接口。
    // 把几何体的方法都罗列出来
    type geometry interface { 
        area() float64
        perim() float64
    }
    
    // 矩形 结构体
    type square struct { 
        width, height float64
    }
    // 圆形 结构体
    type circle struct { 
        radius float64
    }
    
    // 定义矩形结构体的方法
    func (s square) area() float64 { 
        return s.width * s.height
    }
    func (s square) perim() float64 { 
        return 2*s.width + 2*s.height
    }
    
    // 定义圆形结构体的方法
    func (c circle) area() float64 { 
        return math.Pi * c.radius * c.radius
    }
    func (c circle) perim() float64 { 
        return 2 * math.Pi * c.radius
    }
    
    // 将接口当做参数，传入到measure函数中,类型是geometry，形参是g
    // 我们实际传入的是结构体的实例
    // 接口定义了一些方法名，这个实例也实现了对应的方法名
    // 在函数中，就可以直接调用了
    func measure(g geometry) { 
        fmt.Println(g)
        fmt.Println(g.area())
        fmt.Println(g.perim())
    }
    
    func main() { 
        // 创建结构体实例
        s := square{ width: 3, height: 4}
        c := circle{ radius: 5}
    
        // 执行函数
        measure(s)
        measure(c)
    }