传递接口指针给函数以操作结构体指针

golang学习网今天将给大家带来《传递接口指针给函数以操作结构体指针》，感兴趣的朋友请继续看下去吧！以下内容将会涉及到等等知识点，如果你是正在学习Golang或者已经是大佬级别了，都非常欢迎也希望大家都能给我建议评论哈~希望能帮助到大家！

我试图理解以接口指针作为参数的函数的问题，但仍然不完全理解这个问题，所以如果这是一个重复的问题，我深表歉意。虽然我理解普遍的观点是通常不需要指向接口的指针，但我觉得我实际上处于实现它们会很有用的情况。如果情况并非如此，请随时告诉我

我计划从多个证券交易所获取 ohlc 数据。我目前正在为加密货币交易所编写机器人，但也计划为外汇和股票交易所/经纪商开发机器人。目标是将来自每个交换的 ohlc 响应写入 ohlcvals 结构。交易所之间的 ohlc 响应通常不相同，因此这可能会产生一个问题，我希望通过接口来解决这个问题

每个机器人都有自己的 ohlcresponseholder 结构（krakenohlcresponseholder 是一个示例），该结构将实现 ohlcresponseholder 接口的方法。该结构保存一些有关 ohlc 订阅的“元数据”，这些“元数据”通常是特定于交易所的。该列表实际上将在单独的节点中保存每个蜡烛的 ohlc 数据，每个节点的 data 字段也是一个接口。由于每个交易所都有自己的 ohlcresponseholder 结构，我相信我可以通过 ohlcvals 结构中的 vals 字段作为接口来解决大多数问题。因为我需要在新数据进入时更新 ohlcresponseholder 映射中的列表，所以我相信我需要使用指针映射才能进行这些更新。

我相信在这种情况下使用接口指针可能是最好的解决方案，因为我唯一能想到的就是使用泛型。如果我没记错的话，泛型不能与映射一起使用。即使它们能够与地图一起使用，它也可能会变得非常乏味，因为我计划支持许多交换（希望 10-20 个），这将导致通用函数具有许多可接受的数据类型和大量需要测试的一次性边缘情况对于

由于我的函数使用接口指针的用例，我在将结构指针传递给采用接口指针的函数时遇到了一些麻烦。以下是我当前编码的接口和结构：

type candle interface {
    getcandle() candle
    getstarttime() unixtime
    getendtime() unixtime
    gethigh() decimal.decimal
    sethigh(num decimal.decimal)
    getlow() decimal.decimal
    setlow(num decimal.decimal)
    getclose() decimal.decimal
    setclose(num decimal.decimal)
    getvwap() decimal.decimal
    setvwap(num decimal.decimal)
    getvolume() decimal.decimal
    setvolume(num decimal.decimal)
    getcount() int
    setcount(num int)
}

type node struct {
    data candle
    next *node
}

type list interface {
    getlist() list
    addtoend(n *node)
    print(locker *sync.rwmutex)
    isempty() bool
    getlast() *node
}

type list struct {
    head   *node
    last   *node
    length uint
}

func newlist(head *node, last *node, length uint) *list {
    return &list{head: head, last: last, length: length}
}

func (l *list) getlist() list {
    return l
}

func (l *list) addtoend(n *node) {
    if l.head == nil {
        l.head = n
        l.last = n
        l.length++
        return
    }
    tmp := l.last
    tmp.next = n
    l.last = n
    l.length++
}

func (l list) print(locker *sync.rwmutex) {
    locker.rlock()
    tmp := l.head
    for tmp != nil {
        fmt.println(string("\033[34m"), tmp.data, string("\033[0m"))
        tmp = tmp.next
    }
    locker.runlock()
    fmt.println()
}

func (l list) isempty() bool {
    return l.length == 0
}

func (l *list) getlast() *node {
    return l.last
}

type ohlcresponseholder interface {
    getchannelid() int
    getlist() *list
    getinterval() int64
}

type krakenohlcresponseholder struct {
    channelid   int
    interval    int64
    channelname string
    pair        string
    list        shared_types.list
}

func (o krakenohlcresponseholder) getchannelid() int {
    return o.channelid
}

func (o *krakenohlcresponseholder) getlist() *shared_types.list {
    return &o.list
}

func (o krakenohlcresponseholder) getinterval() int64 {
    return o.interval
}

type ohlcvalholder interface {
    set(key int, data *ohlcresponseholder)
    rlock()
    runlock()
    lock()
    unlock()
    getvals() map[int]*ohlcresponseholder
    getmutex() *sync.rwmutex
}

type ohlcvals struct {
    vals  map[int]*shared_types.ohlcresponseholder
    mutex sync.rwmutex
}

func (ohlcvals *ohlcvals) set(key int, data *shared_types.ohlcresponseholder) {
    if ohlcvals.vals == nil {
        ohlcvals.vals = make(map[int]*shared_types.ohlcresponseholder)
    }
    ohlcvals.vals[key] = data
}

func (ohlcvals *ohlcvals) rlock() {
    ohlcvals.mutex.rlock()
}

func (ohlcvals *ohlcvals) runlock() {
    ohlcvals.mutex.runlock()
}

func (ohlcvals *ohlcvals) lock() {
    ohlcvals.mutex.lock()
}

func (ohlcvals *ohlcvals) unlock() {
    ohlcvals.mutex.unlock()
}

func (ohlcvals *ohlcvals) getvals() map[int]*shared_types.ohlcresponseholder {
    return ohlcvals.vals
}

func (ohlcvals *ohlcvals) getmutex() *sync.rwmutex {
    return &ohlcvals.mutex
}

这是使用代码的上下文：

func HandleOHLCResponse(v *types.OHLCResponse, ohlcMap *shared_types.OHLCValHolder) {
    (*ohlcMap).RLock()
    if subID, found := (*ohlcMap).GetVals()[v.ChannelID]; found { // if channelID already exists in the map, then...
        // stuff
        fmt.Println(2+2)    
    } else { // if the channel id cannot be found in the map
        interval, _ := strconv.ParseInt(v.ChannelName[len(v.ChannelName)-1:], 10, 64)
        v.OHLCArray.StartTime.Time = v.OHLCArray.EndTime.Add(-time.Minute * time.Duration(interval))
        node := shared_types.Node{Data: &v.OHLCArray, Next: nil}
        tmp := types.KrakenOHLCResponseHolder{ChannelID: v.ChannelID, ChannelName: v.ChannelName, Pair: v.Pair, Interval: interval, List: shared_types.NewList(&node, &node, 1)}
        (*ohlcMap).RUnlock()

        (*ohlcMap).Lock()
        (*ohlcMap).Set(tmp.ChannelID, &tmp)
        (*ohlcMap).Unlock()
    }
}

这是当我将 &tmp 作为参数传递给 (*ohlcmap).set(tmp.channelid, &tmp) 时得到的错误：无法使用 &tmp（类型 *"bruit/bruit/clients/kraken/ 的值） types".krakenohlcresponseholder) 作为 (*ohlcmap) 参数中的 *shared_types.ohlcresponseholder 值。设置：*"bruit/bruit/clients/kraken/types".krakenohlcresponseholder 未实现 *shared_types.ohlcresponseholder （类型 *shared_types.ohlcresponseholder 是指针到接口，而不是接口）

非常感谢对此的任何帮助

正确答案

类型 *types.ohlcresponseholder 是指向接口类型的指针。

值 &tmp 无法作为 set 类型的第二个参数传递给 *types.ohlcresponseholder：

• &tmp 的 underlying type 是 krakenohlcresponseholder
• *types.ohlcresponseholder 的基础类型是 types.ohlcresponseholder
• 这些类型是 not identical（命名类型仅与其自身相同）
• 因此 &tmp 是 not assignable 到 *types.ohlcresponseholder
• 因此 &tmp can't be converted 为 *types.ohlcresponseholder（参见第一条规则：x 可分配给 t）

如果您使用中间变量，您仍然可以使用 tmp：

var h_tmp types.OhlcResponseHolder = tmp
    (*ohlcMap).Set(tmp.ChannelID, &h_tmp)

这将起作用，因为 &h_tmp 的基础类型是 types.ohlcresponseholder 并且它与函数 set 的第二个参数的类型相同。

这是一个简化的示例：https://go.dev/play/p/zCAe56jg_re

此食谱的问题在于 krakenohlcresponseholder 未实现 ohlcresponseholder - 方法 getlist 是为指针接收器定义的。

以上就是本文的全部内容了，是否有顺利帮助你解决问题？若是能给你带来学习上的帮助，请大家多多支持golang学习网！更多关于Golang的相关知识，也可关注golang学习网公众号。