replace pointer value *a = *b in golang for interface

huangapple
go评论98阅读模式
英文:

replace pointer value *a = *b in golang for interface

问题

可以使用*s = *s2.(*s1)和*s = *s2.(*s2)来替换不同类型但具有相同接口的两个变量的指针值。

  1. package main
  3. import (
  4. 	"log"
  5. )
  7. type i interface {
  8. 	replace(s2 i)
  9. }
  11. type s1 struct {
  12. 	id int
  13. }
  15. func (s *s1) replace(s2 i) {
  16. 	*s = *s2.(*s1)
  17. }
  19. type s2 struct {
  20. 	id float64
  21. }
  23. func (s *s2) replace(s2 i) {
  24. 	*s = *s2.(*s2)
  25. }
  27. func test(s i, s2 i) {
  28. 	s.replace(s2)
  29. }
  31. func main() {
  32. 	s := &s1{1}
  33. 	s2 := &s2{2.0}
  34. 	log.Println(s, s2)
  35. 	test(s, s2)
  36. 	log.Println(s, s2)
  37. }

这段代码无法编译通过：

  1. ./test.go:16: invalid indirect of s2 (type i)
  2. ./test.go:24: invalid indirect of s2 (type i)
英文:

It's possible to replace pointer value using *a = *b for two variables of same type

  1. package main
  3. import (
  4.     "log"
  5. )
  7. type s1 struct {
  8.     id int
  9. }
  11. func (s *s1) replace(s2 *s1) {
  12.     *s = *s2
  13. }
  15. func test(s *s1, s2 *s1) {
  16.     s.replace(s2)
  17. }
  19. func main() {
  20.     s := &s1{1}
  21.     s2 := &s1{2}
  22.     log.Println(s, s2)
  23.     test(s, s2)
  24.     log.Println(s, s2)
  25. }

The result is

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

Is it possible to achieve the same for two variables of different type but same interface?

  1. package main
  3. import (
  4.     "log"
  5. )
  7. type i interface {
  8.     replace(s2 i)
  9. }
  11. type s1 struct {
  12.     id int
  13. }
  15. func (s *s1) replace(s2 i) {
  16.     *s = *s2
  17. }
  19. type s2 struct {
  20.     id float64
  21. }
  23. func (s *s2) replace(s2 i) {
  24.     *s = *s2
  25. }
  27. func test(s i, s2 i) {
  28.     s.replace(s2)
  29. }
  31. func main() {
  32.     s := &s1{1}
  33.     s2 := &s2{2.0}
  34.     log.Println(s, s2)
  35.     test(s, s2)
  36.     log.Println(s, s2)
  37. }

This does not compile

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

答案1

得分: 4

不管它们是否具有相同的接口，*s1和*s2是不同的类型，不能互相赋值。

如果你想通过接口来交换相同类型的值，你可以在方法中添加类型断言：

  1. func (s *s1) replace(swap i) {
  2.     switch t := swap.(type) {
  3.     case *s1:
  4.         *s = *t
  5.     default:
  6.         panic("not the same type")
  7.     }
  8. }
英文:

It doesn't matter if they have the same interface, *s1 and *s2 are different types, and can't be assigned to one another.

If you want to be able to swap the same type through the interface, you can add a type assertion to the method

  1. func (s *s1) replace(swap i) {
  2. 	switch t := swap.(type) {
  3. 	case *s1:
  4. 		*s = *t
  5. 	default:
  6. 		panic("not the same type")
  7. 	}
  8. }

答案2

得分: 0

你可以通过接口指针交换接口的底层值，如果你想要的话：

  1. package main
  3. import "fmt"
  5. type Doer interface {
  6. 	Do()
  7. }
  9. type doInt int
  11. func (i doInt) Do() {
  12. 	fmt.Printf("int: %v\n", i)
  13. }
  15. type doFloat float64
  17. func (f doFloat) Do() {
  18. 	fmt.Printf("float: %v\n", f)
  19. }
  21. func swap(to, from *Doer) {
  22. 	*to = *from
  23. }
  25. func main() {
  26. 	var d1 Doer = doInt(1)
  27. 	var d2 Doer = doFloat(1.1)
  29. 	var d *Doer
  31. 	d = &d1
  33. 	(*d).Do()
  34. 	swap(d, &d2)
  35. 	(*d).Do()
  36. }

但是更简单的方法是直接这样赋值给接口：

  1. func main() {
  2. 	var d Doer = doInt(1)
  3. 	d.Do()
  4. 	d = doFloat(1.1) // swapped!
  5. 	d.Do()
  6. }
英文:

You can swap the underlying values of interfaces via pointers to interfaces, if you want:

  1. package main
  3. import "fmt"
  5. type Doer interface {
  6. 	Do()
  7. }
  9. type doInt int
  11. func (i doInt) Do() {
  12.     fmt.Printf("int: %v\n", i)
  13. }
  15. type doFloat float64
  17. func (f doFloat) Do() {
  18. 	fmt.Printf("float: %v\n", f)
  19. }
  21. func swap(to, from *Doer) {
  22. 	*to = *from
  23. }
  25. func main() {
  26.     var d1 Doer = doInt(1)
  27.     var d2 Doer = doFloat(1.1)
  29.     var d *Doer
  31.     d = &d1
  33.     (*d).Do()
  34.     swap(d, &d2)
  35.     (*d).Do()
  36. }

But it is much easier to simply assign to the interface like this:

  1. func main() {
  2.     var d Doer = doInt(1)
  3.     d.Do()	
  4.     d = doFloat(1.1) // swapped!
  5.     d.Do()
  6. }

huangapple
  • 本文由 发表于 2015年4月10日 01:07:29
  • 转载请务必保留本文链接：https://go.coder-hub.com/29544765.html
  • go
匿名

发表评论

匿名网友

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen:

确定