golang 的指针和非指针方法的见解

绝地灬酷狼 2022-06-07 01:58 373阅读 0赞

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

**先声明一个结构体：**

type T struct {
        Name string
    }
    
    func (t T) M1() {
        t.Name = "name1"
    }
    
    func (t *T) M2() {
        t.Name = "name2"
    }

M1() 的接收者是值类型 T, M2() 的接收者是值类型 \*T , 两个方法内都是改变Name值。

下面声明一个 T 类型的变量，并调用 M1() 和 M2() 。

t1 := T{
       "t1"}
    
        fmt.Println("M1调用前：", t1.Name)
        t1.M1()
        fmt.Println("M1调用后：", t1.Name)
    
        fmt.Println("M2调用前：", t1.Name)
        t1.M2()
        fmt.Println("M2调用后：", t1.Name)

输出结果为：

M1调用前： t1
    M1调用后： t1
    M2调用前： t1
    M2调用后： name2

下面猜测一下go会怎么处理。

先来约定一下：接收者可以看作是函数的第一个参数，即这样的： func M1(t T), func M2(t \*T)。 go不是面向对象的语言，所以用那种看起来像面向对象的语法来理解可能有偏差。

当调用 t1.M1() 时相当于 M1(t1) ，实参和行参都是类型 T，可以接受。此时在M1()中的t只是t1的值拷贝，所以M1()的修改影响不到t1。

当调用 t1.M2() => M2(t1)，这是将 T 类型传给了 \*T 类型，go可能会取 t1 的地址传进去： M2(&t1)。所以 M2() 的修改可以影响 t1 。

T类型的变量只拥有M1方法，不拥有M2，它对M2方法的调用是通过(&t1).M2()实现的，即取t1的地址的方法

下面声明一个 \*T 类型的变量，并调用 M1() 和 M2() 。

t2 := &T{
       "t2"}
    
        fmt.Println("M1调用前：", t2.Name)
        t2.M1()
        fmt.Println("M1调用后：", t2.Name)
    
        fmt.Println("M2调用前：", t2.Name)
        t2.M2()
        fmt.Println("M2调用后：", t2.Name)

输出结果为：

M1调用前： t2
    M1调用后： t2
    M2调用前： t2
    M2调用后： name2

t2.M1() => M1(t2)， t2 是指针类型， 取 t2 的值并拷贝一份传给 M1。

t2.M2() => M2(t2)，都是指针类型，不需要转换。

\*T 类型的变量也是拥有这两个方法的。

传给接口会怎样？

先声明一个接口

type Intf interface { M1() M2() }

使用：

var t1 T = T{
       "t1"}
        t1.M1()
        t1.M2()
    
        var t2 Intf = t1
        t2.M1()
        t2.M2()

报错：

./main.go:9: cannot use t1 (type T) as type Intf in assignment:
        T does not implement Intf (M2 method has pointer receiver)

var t2 Intf = t1 这一行报错。前面说过T类型变量只拥有M1方法，不拥有M2方法

当把 var t2 Intf = t1 修改为 var t2 Intf = &t1 时编译通过，此时 t2 获得的是 t1 的地址， t2.M2() 的修改可以影响到 t1 了。编译之所以通过是因为\*T 类型同时拥有了M1和M2方法

**嵌套类型**

声明一个类型 S，将 T 嵌入进去

type S struct \{ T \}  
使用下面的例子测试一下：

t1 := T{"t1"}     
      s := S{t1}    
    
      fmt.Println("M1调用前：", s.Name)
      s.M1()
      fmt.Println("M1调用后：", s.Name)
    
      fmt.Println("M2调用前：", s.Name)     
      s.M2()     
      fmt.Println("M2调用后：", s.Name)      
      fmt.Println(t1.Name)

输出：

M1调用前： t1 
    M1调用后： t1 
    M2调用前： t1 
    M2调用后： name2

t1 将 T 嵌入 S， 那么 T 拥有的方法和属性 S 也是拥有的，但是接收者却不是 S 而是 T。

所以 s.M1() 相当于 M1(t1) 而不是 M1(s)。

最后 t1 的值没有改变，因为我们嵌入的是 T 类型，所以 S\{t1\} 的时候是将 t1 拷贝了一份。

假如我们将 s 赋值给 Intf 接口会怎么样呢？

var intf Intf = s     
    intf.M1()     
    intf.M2()

报错：

cannot use s (type S) as type Intf in assignment:     
    S does not implement Intf (M2 method has pointer receiver)

还是 M2() 的问题，因为 s 此时还是值类型。

var intf Intf = &s 这样的话编译通过了，如果在 intf.M2() 中改变了 Name 的值， s.Name 被改变了，但是 t1.Name 依然没变，因为现在 t1 和 s 已经没有联系了。

下面嵌入 \*T 试试：

type S struct { *T }

使用时这样：

t1 := T{
       "t1"}     
         s := S{&t1}    
    
         fmt.Println("M1调用前：", s.Name)     
         s.M1()     
         fmt.Println("M1调用后：", s.Name)      
    
         fmt.Println("M2调用前：", s.Name)     
         s.M2()     
         fmt.Println("M2调用后：", s.Name)      
         fmt.Println(t1.Name)

惟一的区别是最后 t1 的值变了，因为我们复制的是指针。

接着赋值给接口试试：

var intf Intf = s 
    intf.M1()     
    intf.M2()     
    fmt.Println(s.Name)

编译没有报错。这里我们传递给 intf 的是值类型而不是指针，为什么可以通过呢？

拷贝 s 的时候里面的 T 是指针类型，所以调用 M2() 的时候传递进去的是一个指针。

var intf Intf = &s 的效果和上面一样。