blocks|key|671524|text|你可以从C调用Go代码，但这是一个令人困惑的命题。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|671525|您链接到的博客帖子中概述了该过程。但我可以看出，这并不是很有帮助。下面是一个简短的代码片段，没有任何不必要的部分。这应该会让事情变得更清晰一些。|671526|package+foo

//+extern+int+goCallbackHandler(int,+int);
//
//+static+int+doAdd(int+a,+int+b)+{
//+++++return+goCallbackHandler(a,+b);
//+}
import+"C"

//export+goCallbackHandler
func+goCallbackHandler(a,+b+C.int)+C.int+{
++++return+a+%2B+b
}

//+This+is+the+public+function,+callable+from+outside+this+package.
//+It+forwards+the+parameters+to+C.doAdd(),+which+in+turn+forwards
//+them+back+to+goCallbackHandler().+This+one+performs+the+addition
//+and+yields+the+result.
func+MyAdd(a,+b+int)+int+{
+++return+int(+C.doAdd(+C.int(a),+C.int(b))+)
}|code-block|syntax|javascript|671527|调用所有内容的顺序如下：|671528|foo.MyAdd(a,+b)+->
++C.doAdd(a,+b)+->
++++C.goCallbackHandler(a,+b)+->
++++++foo.goCallbackHandler(a,+b)|671529|这里要记住的关键是，回调函数在Go端必须标记为//export注释，在C端必须标记为extern。这意味着你想要使用的任何回调都必须在你的包中定义。|offset|length|style|CODE|671530|为了允许包的用户提供自定义回调函数，我们使用与上面完全相同的方法，但我们提供了用户的自定义处理程序(这只是一个常规的Go函数)作为参数，该参数作为void*传递到C端。然后由我们包中的回调处理程序接收并调用。|671531|让我们使用一个我目前正在使用的更高级的示例。在本例中，我们有一个C函数，它执行一项相当繁重的任务:它从USB设备读取文件列表。这可能需要一段时间，所以我们希望通知我们的应用程序它的进度。我们可以通过传入我们在程序中定义的函数指针来做到这一点。每当它被调用时，它只是向用户显示一些进度信息。由于它有一个众所周知的签名，我们可以为它分配自己的类型：|671532|type+ProgressHandler+func(current,+total+uint64,+userdata+interface{})+int|671533|这个处理程序接受一些进度信息(当前接收的文件数和文件总数)以及一个interface{}值，该值可以保存用户需要它保存的任何内容。|671534|现在，我们需要编写C并执行管道操作，以允许我们使用此处理程序。幸运的是，我希望从库中调用的C函数允许我们传入void*类型的用户数据结构。这意味着它可以容纳我们想让它容纳的任何东西，没有任何问题，我们将把它带回Go世界。为了完成所有这些工作，我们没有直接从Go调用库函数，但是我们为它创建了一个C包装器，我们将其命名为goGetFiles()。实际上，这个包装器提供了对C库的Go回调，以及一个userdata对象。|671535|package+foo

//+#include+<somelib.h>
//+extern+int+goProgressCB(uint64_t+current,+uint64_t+total,+void*+userdata);
//+
//+static+int+goGetFiles(some_t*+handle,+void*+userdata)+{
//++++return+somelib_get_files(handle,+goProgressCB,+userdata);
//+}
import+"C"
import+"unsafe"|671536|请注意，goGetFiles()函数没有将任何用于回调的函数指针作为参数。相反，我们的用户提供的回调被打包在一个自定义结构中，该结构同时包含该处理程序和用户自己的userdata值。我们将其作为userdata参数传递给goGetFiles()。|671537|//+This+defines+the+signature+of+our+user's+progress+handler,
type+ProgressHandler+func(current,+total+uint64,+userdata+interface{})+int+

//+This+is+an+internal+type+which+will+pack+the+users+callback+function+and+userdata.
//+It+is+an+instance+of+this+type+that+we+will+actually+be+sending+to+the+C+code.
type+progressRequest+struct+{
+++f+ProgressHandler++//+The+user's+function+pointer
+++d+interface{}++++++//+The+user's+userdata.
}

//export+goProgressCB
func+goProgressCB(current,+total+C.uint64_t,+userdata+unsafe.Pointer)+C.int+{
++++//+This+is+the+function+called+from+the+C+world+by+our+expensive+
++++//+C.somelib_get_files()+function.+The+userdata+value+contains+an+instance
++++//+of+*progressRequest,+We+unpack+it+and+use+it's+values+to+call+the
++++//+actual+function+that+our+user+supplied.
++++req+:=+(*progressRequest)(userdata)

++++//+Call+req.f+with+our+parameters+and+the+user's+own+userdata+value.
++++return+C.int(+req.f(+uint64(current),+uint64(total),+req.d+)+)
}

//+This+is+our+public+function,+which+is+called+by+the+user+and
//+takes+a+handle+to+something+our+C+lib+needs,+a+function+pointer
//+and+optionally+some+user+defined+data+structure.+Whatever+it+may+be.
func+GetFiles(h+*Handle,+pf+ProgressFunc,+userdata+interface{})+int+{
+++//+Instead+of+calling+the+external+C+library+directly,+we+call+our+C+wrapper.
+++//+We+pass+it+the+handle+and+an+instance+of+progressRequest.

+++req+:=+unsafe.Pointer(&progressequest{+pf,+userdata+})
+++return+int(C.goGetFiles(+(*C.some_t)(h),+req+))
}|671538|这就是我们的C绑定。用户的代码现在非常简单：|671539|package+main

import+(
++++"foo"
++++"fmt"
)

func+main()+{
++++handle+:=+SomeInitStuff()

++++//+We+call+GetFiles.+Pass+it+our+progress+handler+and+some
++++//+arbitrary+userdata+(could+just+as+well+be+nil).
++++ret+:=+foo.GetFiles(+handle,+myProgress,+"Callbacks+rock!"+)

++++....
}

//+This+is+our+progress+handler.+Do+something+useful+like+display.
//+progress+percentage.
func+myProgress(current,+total+uint64,+userdata+interface{})+int+{
++++fc+:=+float64(current)
++++ft+:=+float64(total)+*+0.01

++++//+print+how+far+along+we+are.
++++//+eg:+500+/+1000+(50.00%25)
++++//+For+good+measure,+prefix+it+with+our+userdata+value,+which
++++//+we+supplied+as+"Callbacks+rock!".
++++fmt.Printf("%25s:+%25d+/+%25d+(%253.2f%25%25)\n",+userdata.(string),+current,+total,+fc+/+ft)
++++return+0
}|671540|这一切看起来都比实际情况复杂得多。与我们前面的示例相反，调用顺序没有改变，但我们在链的末尾获得了两个额外的调用：|671541|顺序如下：|671542|foo.GetFiles(....)+->
++C.goGetFiles(...)+->
++++C.somelib_get_files(..)+->
++++++C.goProgressCB(...)+->
++++++++foo.goProgressCB(...)+->
+++++++++++main.myProgress(...)|671543|entityMap^0|0|0|0|0|0|N|8|16|6|0|21|5|0|0|0|0|1I|5|4F|C|0|0|4|C|32|C|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|1M|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|1N|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|1O|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|1P|8|@$O|1Q|P|1R|Q|R]|$O|1S|P|1T|Q|R]]|9|@]|A|$]]|$1|S|3|T|5|6|7|1U|8|@$O|1V|P|1W|Q|R]]|9|@]|A|$]]|$1|U|3|V|5|6|7|1X|8|@]|9|@]|A|$]]|$1|W|3|X|5|F|7|1Y|8|@]|9|@]|A|$G|H]]|$1|Y|3|Z|5|6|7|1Z|8|@]|9|@]|A|$]]|$1|10|3|11|5|6|7|20|8|@$O|21|P|22|Q|R]|$O|23|P|24|Q|R]]|9|@]|A|$]]|$1|12|3|13|5|F|7|25|8|@]|9|@]|A|$G|H]]|$1|14|3|15|5|6|7|26|8|@$O|27|P|28|Q|R]|$O|29|P|2A|Q|R]]|9|@]|A|$]]|$1|16|3|17|5|F|7|2B|8|@]|9|@]|A|$G|H]]|$1|18|3|19|5|6|7|2C|8|@]|9|@]|A|$]]|$1|1A|3|1B|5|F|7|2D|8|@]|9|@]|A|$G|H]]|$1|1C|3|1D|5|6|7|2E|8|@]|9|@]|A|$]]|$1|1E|3|1F|5|6|7|2F|8|@]|9|@]|A|$]]|$1|1G|3|1H|5|F|7|2G|8|@]|9|@]|A|$G|H]]|$1|1I|3|-4|5|6|7|2H|8|@]|9|@]|A|$]]]|1J|$]]

You can call Go code from C. it is a confusing proposition though. 

The process is outlined in the blog post you linked to. But I can see how that isn't very helpful. Here is a short snippet without any unnecessary bits. It should make things a little clearer.

<pre><code>package foo

// extern int goCallbackHandler(int, int);
//
// static int doAdd(int a, int b) {
// return goCallbackHandler(a, b);
// }
import "C"

//export goCallbackHandler
func goCallbackHandler(a, b C.int) C.int {
 return a + b
}

// This is the public function, callable from outside this package.
// It forwards the parameters to C.doAdd(), which in turn forwards
// them back to goCallbackHandler(). This one performs the addition
// and yields the result.
func MyAdd(a, b int) int {
 return int( C.doAdd( C.int(a), C.int(b)) )
}
</code></pre>

The order in which everything is called is as follows:

<pre><code>foo.MyAdd(a, b) -&gt;
 C.doAdd(a, b) -&gt;
 C.goCallbackHandler(a, b) -&gt;
 foo.goCallbackHandler(a, b)
</code></pre>

The key to remember here is that a callback function must be marked with the <code>//export</code> comment on the Go side and as <code>extern</code> on the C side. This means that any callback you wish to use, must be defined inside your package. 

In order to allow a user of your package to supply a custom callback function, we use the exact same approach as above, but we supply the user's custom handler (which is just a regular Go function) as a parameter that is passed onto the C side as <code>void*</code>. It is then received by the callbackhandler in our package and called.

Let's use a more advanced example I am currently working with. In this case, we have a C function that performs a pretty heavy task: It reads a list of files from a USB device. This can take a while, so we want our app to be notified of its progress. We can do this by passing in a function pointer that we defined in our program. It simply displays some progress info to the user whenever it gets called. Since it has a well known signature, we can assign it its own type:

<pre><code>type ProgressHandler func(current, total uint64, userdata interface{}) int
</code></pre>

This handler takes some progress info (current number of files received and total number of files) along with an interface{} value which can hold anything the user needs it to hold.

Now we need to write the C and Go plumbing to allow us to use this handler. Luckily the C function I wish to call from the library allows us to pass in a userdata struct of type <code>void*</code>. This means it can hold whatever we want it to hold, no questions asked and we will get it back into the Go world as-is. To make all this work, we do not call the library function from Go directly, but we create a C wrapper for it which we will name <code>goGetFiles()</code>. It is this wrapper that actually supplies our Go callback to the C library, along with a userdata object.

<pre><code>package foo

// #include &lt;somelib.h&gt;
// extern int goProgressCB(uint64_t current, uint64_t total, void* userdata);
// 
// static int goGetFiles(some_t* handle, void* userdata) {
// return somelib_get_files(handle, goProgressCB, userdata);
// }
import "C"
import "unsafe"
</code></pre>

Note that the <code>goGetFiles()</code> function does not take any function pointers for callbacks as parameters. Instead, the callback that our user has supplied is packed in a custom struct that holds both that handler and the user's own userdata value. We pass this into <code>goGetFiles()</code> as the userdata parameter.

<pre><code>// This defines the signature of our user's progress handler,
type ProgressHandler func(current, total uint64, userdata interface{}) int 

// This is an internal type which will pack the users callback function and userdata.
// It is an instance of this type that we will actually be sending to the C code.
type progressRequest struct {
 f ProgressHandler // The user's function pointer
 d interface{} // The user's userdata.
}

//export goProgressCB
func goProgressCB(current, total C.uint64_t, userdata unsafe.Pointer) C.int {
 // This is the function called from the C world by our expensive 
 // C.somelib_get_files() function. The userdata value contains an instance
 // of *progressRequest, We unpack it and use it's values to call the
 // actual function that our user supplied.
 req := (*progressRequest)(userdata)

 // Call req.f with our parameters and the user's own userdata value.
 return C.int( req.f( uint64(current), uint64(total), req.d ) )
}

// This is our public function, which is called by the user and
// takes a handle to something our C lib needs, a function pointer
// and optionally some user defined data structure. Whatever it may be.
func GetFiles(h *Handle, pf ProgressFunc, userdata interface{}) int {
 // Instead of calling the external C library directly, we call our C wrapper.
 // We pass it the handle and an instance of progressRequest.

 req := unsafe.Pointer(&amp;progressequest{ pf, userdata })
 return int(C.goGetFiles( (*C.some_t)(h), req ))
}
</code></pre>

That's it for our C bindings. The user's code is now very straight forward:

<pre><code>package main

import (
 "foo"
 "fmt"
)

func main() {
 handle := SomeInitStuff()

 // We call GetFiles. Pass it our progress handler and some
 // arbitrary userdata (could just as well be nil).
 ret := foo.GetFiles( handle, myProgress, "Callbacks rock!" )

 ....
}

// This is our progress handler. Do something useful like display.
// progress percentage.
func myProgress(current, total uint64, userdata interface{}) int {
 fc := float64(current)
 ft := float64(total) * 0.01

 // print how far along we are.
 // eg: 500 / 1000 (50.00%)
 // For good measure, prefix it with our userdata value, which
 // we supplied as "Callbacks rock!".
 fmt.Printf("%s: %d / %d (%3.2f%%)\n", userdata.(string), current, total, fc / ft)
 return 0
}
</code></pre>

This all looks a lot more complicated than it is. The call order has not changed as opposed to our previous example, but we get two extra calls at the end of the chain:

The order is as follows:

<pre><code>foo.GetFiles(....) -&gt;
 C.goGetFiles(...) -&gt;
 C.somelib_get_files(..) -&gt;
 C.goProgressCB(...) -&gt;
 foo.goProgressCB(...) -&gt;
 main.myProgress(...)
</code></pre>

blocks|key|888694|text|如果您使用gccgo，这不是一个令人困惑的命题。它在这里起作用：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|888695|foo.go|888696|package+main

func+Add(a,+b+int)+int+{
++++return+a+%2B+b
}|code-block|syntax|javascript|888697|bar.c|888698|#include+<stdio.h>

extern+int+go_add(int,+int)+__asm__+("example.main.Add");

int+main()+{
++int+x+=+go_add(2,+3);
++printf("Result:+%25d\n",+x);
}|888699|Makefile|888700|all:+main

main:+foo.o+bar.c
++++gcc+foo.o+bar.c+-o+main

foo.o:+foo.go
++++gccgo+-c+foo.go+-o+foo.o+-fgo-prefix=example

clean:
++++rm+-f+main+*.o|888701|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|V|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|W|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|X|8|@]|9|@]|A|$]]|$1|O|3|P|5|F|7|Y|8|@]|9|@]|A|$G|H]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

It is not a confusing proposition if you use gccgo. This works here:

<h1>foo.go</h1>

<pre><code>package main

func Add(a, b int) int {
 return a + b
}
</code></pre>

<h1>bar.c</h1>

<pre><code>#include &lt;stdio.h&gt;

extern int go_add(int, int) __asm__ ("example.main.Add");

int main() {
 int x = go_add(2, 3);
 printf("Result: %d\n", x);
}
</code></pre>

<h1>Makefile</h1>

<pre><code>all: main

main: foo.o bar.c
 gcc foo.o bar.c -o main

foo.o: foo.go
 gccgo -c foo.go -o foo.o -fgo-prefix=example

clean:
 rm -f main *.o
</code></pre>

blocks|key|671622|text|随着Go+1.5的发布，答案发生了变化|type|unstyled|depth|inlineStyleRanges|entityRanges|data|671623|我前段时间问的这个问题，根据1.5增加的功能再次解决了这个问题|671624|Using+Go+code+in+an+existing+C+project|offset|length|671625|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/32215509/using-go-code-in-an-existing-c-project^0|0|0|0|12|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Q|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|R|8|@]|9|@$F|S|G|T|1|U]]|A|$]]|$1|H|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|I|$J|$5|K|L|M|A|$N|O]]]]

The answer has changed with the release of Go 1.5

This SO question that I asked some time ago addresses the issue again in light of the 1.5 added capabilities

<a href="https://stackoverflow.com/questions/32215509/using-go-code-in-an-existing-c-project">Using Go code in an existing C project</a>

I am trying to create a static object written in Go to interface with a C program (say, a kernel module or something).

I have found documentation on calling C functions from Go, but I haven't found much on how to go the other way. What I've found is that it's possible, but complicated.

Here is what I found:

<a href="http://cheesesun.blogspot.com/2010/04/callbacks-in-cgo.html">Blog post about callbacks between C and Go</a>

<a href="http://golang.org/cmd/cgo/">Cgo documentation</a>

<a href="http://groups.google.com/group/golang-nuts/browse_thread/thread/4de85861de6ef204/f7d610e08b86d437?lnk=gst&amp;q=cgo+dynamic+linking+D#f7d610e08b86d437">Golang mailing list post</a>

Does anyone have experience with this? In short, I'm trying to create a PAM module written entirely in Go.

Call Go functions from C

数据结构

我正在尝试创建一个用Go编写的静态对象，以便与C程序(例如，内核模块或其他程序)进行接口。我找到了关于从Go调用C函数的文档，但我还没有找到太多关于如何从go调用C函数的文档。我发现这是可能的，但很复杂。这是我发现的：有没有人有这方面的经验？简而言之，我正在尝试创建一个完全用Go编写的PAM模块。

问从C++调用Go函数
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问从C++调用Go函数EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问从C++调用Go函数
EN