Question

可以使用* a = * b替换相同类型的两个变量的指针值

package main

import (
    "log"
)

type s1 struct {
    id int
}

func (s *s1) replace(s2 *s1) {
    *s = *s2
}

func test(s *s1, s2 *s1) {
    s.replace(s2)
}

func main() {
    s := &s1{1}
    s2 := &s1{2}
    log.Println(s, s2)
    test(s, s2)
    log.Println(s, s2)
}

结果是

2015/04/09 16:57:00 &{1} &{2}
2015/04/09 16:57:00 &{2} &{2}

是否可以为不同类型但相同接口的两个变量实现相同的目标？

package main

import (
    "log"
)

type i interface {
    replace(s2 i)
}

type s1 struct {
    id int
}

func (s *s1) replace(s2 i) {
    *s = *s2
}

type s2 struct {
    id float64
}

func (s *s2) replace(s2 i) {
    *s = *s2
}

func test(s i, s2 i) {
    s.replace(s2)
}

func main() {
    s := &s1{1}
    s2 := &s2{2.0}
    log.Println(s, s2)
    test(s, s2)
    log.Println(s, s2)
}

这不编译

./test.go:16: invalid indirect of s2 (type i)
./test.go:24: invalid indirect of s2 (type i)

Answer 1

如果它们具有相同的界面并不重要，*s1和*s2是不同的类型，并且不能彼此分配。

如果您希望能够通过界面交换相同的类型，可以在方法中添加类型断言

func (s *s1) replace(swap i) {
    switch t := swap.(type) {
    case *s1:
        *s = *t
    default:
        panic("not the same type")
    }
}

Answer 2

如果需要，可以通过指向接口的接口交换接口的基础值：

package main

import "fmt"

type Doer interface {
    Do()
}

type doInt int

func (i doInt) Do() {
    fmt.Printf("int: %v\n", i)
}

type doFloat float64

func (f doFloat) Do() {
    fmt.Printf("float: %v\n", f)
}

func swap(to, from *Doer) {
    *to = *from
}

func main() {
    var d1 Doer = doInt(1)
    var d2 Doer = doFloat(1.1)

    var d *Doer

    d = &d1

    (*d).Do()
    swap(d, &d2)
    (*d).Do()
}

但是简单地分配到这样的界面要容易得多：

func main() {
    var d Doer = doInt(1)
    d.Do()  
    d = doFloat(1.1) // swapped!
    d.Do()
}

在golang中替换指针值* a = * b作为接口

2 个答案: