TL;DR 不知何故,我将一个指针 append 到列表而不是对象的 for 循环中的对象,所以最后整个 slice 多次由同一个对象组成。我只是不知道如何解决这个问题。
漫漫长路
我仍然很难在 go 中找出指针。我昨天发布了一个问题并得到了一些帮助,但现在我在同一段代码中遇到了一个稍微不同的问题。
我正在使用 gocql
和 cqlr
go 包来尝试为我的 Cassandra 查询编写一个小型对象映射器。从本质上讲,我遇到的问题是我将似乎是指向对象的指针,而不是 obj 的新实例 append 到数组中。我该如何解决?我尝试在 value
前面添加 &
和 *
但这似乎不起作用。我该如何解决这些问题?根据他们的文档,绑定(bind)函数需要一个 &
。
代码
type Query struct {
query string
values interface{}
attempts int
maxAttempts int
structType reflect.Type
}
func (query Query) RetryingQuery() (results []interface{}) {
var q *gocql.Query
if query.values != nil {
q = c.Session.Query(query.query, query.values)
} else {
q = c.Session.Query(query.query)
}
bindQuery := cqlr.BindQuery(q)
value := reflect.New(query.structType).Interface()
for bindQuery.Scan(value) {
fmt.Println(value)
results = append(results, value)
}
return
}
文档要求 var value type
然后在绑定(bind)中你将传递 &value
。我引用了下面的文档。
var t Tweet
var s []Tweet
for b.Scan(&t) {
// Application specific code goes here
append(s, t)
}
问题是我不能直接去 var value query.structType
定义它的类型,然后将它的引用传递给 bindQuery.Scan()
。
打印什么
&{result1 x86_64 24 3.2.0-74-generic Linux}
&{result2 x86_64 24 3.19.0-25-generic Linux}
&{result3 x86_64 4 3.13.0-48-generic Linux}
&{result4 x86_64 2 3.13.0-62-generic Linux}
&{result5 x86_64 4 3.13.0-48-generic Linux}
slice 里有什么
剧透,result5
一遍又一遍地重复。我知道我只是将指向同一对象的指针 append 到列表中,并且每次循环迭代都会更改该对象,并将 slice 中的所有结果更改为该新对象。我只是不知道如何修复它。
[{"hostname":"result5","machine":"x86_64","num_cpus":4,"release":"3.13.0-48-generic","sysname":"Linux"},{"hostname":"result5","machine":"x86_64","num_cpus":4,"release":"3.13.0-48-generic","sysname":"Linux"},{"hostname":"result5","machine":"x86_64","num_cpus":4,"release":"3.13.0-48-generic","sysname":"Linux"},{"hostname":"result5","machine":"x86_64","num_cpus":4,"release":"3.13.0-48-generic","sysname":"Linux"},{"hostname":"result5","machine":"x86_64","num_cpus":4,"release":"3.13.0-48-generic","sysname":"Linux"}]
最佳答案
好吧,我至少可以告诉你你在做什么。 bindQuery
接受一个指针。它会更改地址中存储的值。
你实际上在做的是:
package main
import "fmt"
func main() {
var q int
myInts := make([]*int, 0, 5)
for i := 0; i < 5; i++ {
q = i
fmt.Printf("%d ", q)
myInts = append(myInts, &q)
}
fmt.Printf("\n")
for _, value := range myInts {
fmt.Printf("%d ", *value)
}
fmt.Printf("\n")
fmt.Println(myInts)
}
正如您可能猜到的那样,它给了您:
0 1 2 3 4
4 4 4 4 4
[0x104382e0 0x104382e0 0x104382e0 0x104382e0 0x104382e0]
reflect
会让事情变得更加困惑。您可以将类型作为接口(interface)获取,但仅此而已(除非您想使用 unsafe
)。简单来说,一个接口(interface)包含一个指向下面原始类型(以及其他一些东西)的指针。所以在你的函数中你传递了一个指针(和其他一些东西)。然后你追加指针。获得具体的类型并切换您的界面可能会很好。我假设你知道它可能是什么类型。在这种情况下,您必须遵循以下原则:
package main
import (
"fmt"
"reflect"
)
type foo struct {
fooval string
}
type bar struct {
barval string
}
func main() {
f1 := foo{"hi"}
f2 := &foo{"hi"}
b1 := bar{"bye"}
b2 := &bar{"bye"}
doSomething(f1)
doSomething(f2)
doSomething(b1)
doSomething(b2)
}
func doSomething(i interface{}) {
n := reflect.TypeOf(i)
// get a new one
newn := reflect.New(n).Interface()
// find out what we got and handle each case
switch t := newn.(type) {
case **foo:
*t = &foo{"hi!"}
fmt.Printf("It was a **foo, here is the address %p and here is the value %v\n", *t, **t)
case **bar:
*t = &bar{"bye :("}
fmt.Printf("It was a **bar, here is the address %p and here is the value %v\n", *t, **t)
case *foo:
t = &foo{"hey!"}
fmt.Printf("It was a *foo, here is the address %p and here is the value %v\n", t, *t)
case *bar:
t = &bar{"ahh!"}
fmt.Printf("It was a *bar, here is the address %p and here is the value %v\n", t, *t)
default:
panic("AHHHH")
}
}
您也可以在循环内继续调用 value = reflect.New(query.structType).Interface()
,这样每次都会为您提供新的接口(interface)。每次 append 后重新分配值。最后一次通过循环会多做一个..
关于pointers - 指针问题,我们在Stack Overflow上找到一个类似的问题: https://stackoverflow.com/questions/33786353/