C в .go файлове

package main

#include <stdlib.h>
import "C"

func Random() int {
    return int(C.random())

func Seed(i int) {


// #cgo amd64 386 CFLAGS: -DX86=1
// #cgo LDFLAGS: -lpng
// #include <png.h>
import "C"
// #cgo pkg-config: png cairo

Още от магиите на "C"

Error handling

n, err := C.sqrt(-1)

Function pointers


package main

// typedef int (*intFunc) ();
// int
// bridge_int_func(intFunc f)
// {
//      return f();
// }
// int fortytwo()
// {
//      return 42;
// }
import "C"
import "fmt"

func main() {
    f := C.intFunc(C.fortytwo)
    // Output: 42

А как се вика Go код от С?

//export MyFunction
func MyFunction(arg1, arg2 int, arg3 string) int64 {...}
extern int64 MyFunction(int arg1, int arg2, GoString arg3);


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 {
    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(, )

Ето какво и в какъв ред се извиква:

foo.MyAdd(a, b) ->
  C.doAdd(a, b) ->
    C.goCallbackHandler(a, b) ->
      foo.goCallbackHandler(a, b)

По-сложен пример

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"

По-сложен пример (2)

// 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.

По-сложен пример (3)

//export goProgressCB
func goProgressCB(current, total C.uint64_t, userdata unsafe.Pointer) {
    // 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 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 ProgressHandler, 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(&progressRequest{ pf, userdata })
   return int(C.goGetFiles( (*C.some_t)(h), req ))

По-сложен пример (4)

package main

import (

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!" )


По-сложен пример (5)

// 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

По-сложен пример (6)

foo.GetFiles(....) ->
  C.goGetFiles(...) ->
    C.somelib_get_files(..) ->
      C.goProgressCB(...) ->
        foo.goProgressCB(...) ->

Друг начин за викане на Go от C

package main

func Add(a, b int) int {
    return a + b

Друг начин за викане на Go от C (2)

#include <stdio.h>

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

int main() {
  int x = go_add(2, 3);
  printf("Result: %d\n", x);

Друг начин за викане на Go от C (3)

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

    rm -f main *.o