Golang函数指针作为结构的一部分

user340495：

我有以下代码：

type FWriter struct {
    WriteF func(p []byte) (n int,err error)
}

func (self *FWriter) Write(p []byte) (n int, err error) {
    return self.WriteF(p)
}

func MyWriteFunction(p []byte) (n int, err error) { 
    // this function implements the Writer interface but is not named "Write"
    fmt.Print("%v",p)
    return len(p),nil
}

MyFWriter := new(FWriter)
MyFWriter.WriteF = MyWriteFunction
// I want to use MyWriteFunction with io.Copy
io.Copy(MyFWriter,os.Stdin)

我想要做的是创建一个Writer接口进行包装，MyWriteFunction因为它没有命名为“ Write”，并且我不能将其与任何需要“ Writer”接口的东西一起使用。

该代码无法正常工作，因为它抱怨：

方法MyWriterFunction不是表达式，必须调用

我在这里做错了什么？如何设置WriteF是MyWriteFunction？

注意：我已尽最大可能简化了此问题，实际上我有一个具有MyWriteFunctionAND普通Write函数的结构，因此它有点复杂...（此外，如果有更好的方法来解决我的问题，那么我会很高兴听到的！）

谢谢！！

编辑：我注意到我的错字并修正了（MyWriterFunction-> MyWriteFunction）。

我认为我过分简化了问题，以致使您误解了我的初衷。在匿名评论和peterSO类评论之后，我重新创建了错误以更好地演示我的问题：

package main

import (
    "fmt"
    "io"
    "strings"
)

type ProxyWrite interface {
    Write(p []byte) (n int, err error)
    SpecialWrite(p []byte) (n int, err error)
}

type Implementer struct {
    counter int
}

func (self Implementer) Write(p []byte) (n int, err error) {
    fmt.Print("Normal write: %v", p)
    return len(p),nil
}

func (self Implementer) SpecialWrite(p []byte) (n int, err error) {
    fmt.Print("Normal write: %v\n", p)
    fmt.Println("And something else")
    self.counter += 1
    return len(p),nil
}


type WriteFunc func(p []byte) (n int, err error)

func (wf WriteFunc) Write(p []byte) (n int, err error) {
    return wf(p)
}

func main() {
    Proxies := make(map[int]ProxyWrite,2)
    Proxies[1] = new(Implementer)
    Proxies[2] = new(Implementer)

    /* runs and uses the Write method normally */
    io.Copy(Proxies[1], strings.NewReader("Hello world"))
    /* gets ./main.go:45: method Proxies[1].SpecialWrite is not an expression, must be called */
    io.Copy(WriteFunc(Proxies[1].SpecialWrite), strings.NewReader("Hello world"))
}

我希望它能澄清我在第一次尝试中要表达的意思。

有什么想法吗？

保罗·汉金：

您的代码中有错别字，但是无论如何都不需要将函数包装到结构中。相反，您可以只定义一个包装函数的WriteFunc类型，并可以在其上定义Write方法。这是一个完整的例子。

package main

import (
    "fmt"
    "io"
    "strings"
)

type WriteFunc func(p []byte) (n int, err error)

func (wf WriteFunc) Write(p []byte) (n int, err error) {
    return wf(p)
}

func myWrite(p []byte) (n int, err error) {
    fmt.Print("%v", p)
    return len(p), nil
}

func main() {
    io.Copy(WriteFunc(myWrite), strings.NewReader("Hello world"))
}

本文收集自互联网，转载请注明来源。

如有侵权，请联系 [email protected] 删除。