Calling Go Functions from c++

As programmers we sometimes need to do weird stuff or make two systems work together that really should not interoperate. As is the case with c++ and go in the way of calling functions written in go from c++. But I didnt ask if i should, i just asked if i could and the result is documented in the form of this blog post and the repo here.

Project setup ##

The flow of our project will be to compile the go file to an archive with the go toolchain. We will then use the gnu c++ compiler to link our c++ code calling functions from the go library with the compiled archive.

Compiling a go file to an archive:

1go build -buildmode=c-archive -o lib.a lib.go

Compiling a c++ file and linking it against the afore compiled archive:

1g++ -Wall main.cpp lib.a -o main

To make our iteration loop faster we will use make and insert the invocation of the resulting binary to our example target:

1example:
2	go build -buildmode=c-archive -o lib.a lib.go
3	g++ -Wall main.cpp lib.a -o main
4	./main

Simple example ##

We will start with some easy stuff and wrap the go standard library methods for the square root and the n-th power, export them and call them from c++.

The first step is to create both lib.go and main.cpp and fill them with the following boilerplate:

1// lib.go
2package main
3
4import "C"
5import ()
6
7func main() {}

1// main.cpp
2#include "lib.h"
3int main() {}

We can now check if our project setup works:

1$ make
2go build -buildmode=c-archive -o lib.a lib.go
3g++ -Wall main.cpp lib.a -o main
4./main

Lets now wrap both math.Sqrt and math.Pow in go functions, export them and invoke them from c++ to get a feel for the interaction logic. Starting of with the definition in lib.go:

 1package main
 2
 3import "C"
 4import (
 5	"math"
 6)
 7
 8//export Sqrt
 9func Sqrt(n float64) float64 {
10	return math.Sqrt(n)
11}
12
13//export Pow
14func Pow(x float64, y float64) float64 {
15	return math.Pow(x, y)
16}
17
18func main() {}

All exported functions need to start with an uppercase letter (as defined in the go spec) and require a comment above them with the name of the function it should be invoked by from the c++ context.

We can now modify our c++ and create a small function to call the functions we defined above:

 1#include "lib.h"
 2#include <iostream>
 3
 4void maths() {
 5  GoFloat64 sqrt = Sqrt(25.0);
 6  std::cout << "sqrt(25.0)=" << sqrt << std::endl;
 7  GoFloat64 pow = Pow(5, 3);
 8  std::cout << "power(5, 3)=" << pow << std::endl;
 9}
10
11int main() {
12  maths();
13}

1typedef double GoFloat64;

 1// ...
 2typedef signed char GoInt8;
 3typedef unsigned char GoUint8;
 4typedef short GoInt16;
 5typedef unsigned short GoUint16;
 6typedef int GoInt32;
 7typedef unsigned int GoUint32;
 8typedef long long GoInt64;
 9typedef unsigned long long GoUint64;
10typedef GoInt64 GoInt;
11typedef GoUint64 GoUint;
12typedef size_t GoUintptr;
13typedef float GoFloat32;
14// ...

 1#ifdef __cplusplus
 2extern "C" {
 3#endif
 4
 5extern GoFloat64 Sqrt(GoFloat64 n);
 6extern GoFloat64 Pow(GoFloat64 x, GoFloat64 y);
 7
 8#ifdef __cplusplus
 9}
10#endif

Running our example via make:

1$ make
2go build -buildmode=c-archive -o lib.a lib.go
3g++ -Wall main.cpp lib.a -o main
4./main
5sqrt(25.0)=5
6power(5, 3)=125

Web requests and passing strings to go ##

Lets take a look at the possibility of making a get request to an URL. For that we implement the Request method in lib.go:

 1package main
 2
 3import "C"
 4import (
 5	"math"
 6	"net/http"
 7	"time"
 8)
 9
10// ...
11
12//export Request
13func Request(str string) int {
14	client := http.Client{
15		Timeout: time.Millisecond * 200,
16	}
17	resp, _ := client.Get(str)
18	return resp.StatusCode
19}
20
21// ...

However the conventional string used in the go runtime differs from the string used in c++. To help us with this, the toolchain generated a type definition in lib.h:

1#ifndef GO_CGO_GOSTRING_TYPEDEF
2typedef struct { const char *p; ptrdiff_t n; } _GoString_;
3#endif
4// ...
5#ifndef GO_CGO_GOSTRING_TYPEDEF
6typedef _GoString_ GoString;
7#endif

We can create an instance of this structure and pass it to our Request function:

 1#include "lib.h"
 2#include <cstring>
 3
 4// ...
 5
 6void request(const char *s) {
 7  GoString str;
 8  str.p = s;
 9  str.n = strlen(str.p);
10  int r = Request(str);
11  std::cout << "http.Get(" << str.p << ")=" << r << std::endl;
12}
13
14int main() {
15  // ...
16  request("https://xnacly.me/5");
17  request("https://xnacly.me/about");
18}

GoString.n is the length of the string and GoString.p refers to the pointer to the string. Lets test the request to an invalid page and the request to a valid page:

1$ make
2go build -buildmode=c-archive -o lib.a lib.go
3g++ -Wall main.cpp lib.a -o main
4./main
5http.Get(https://xnacly.me/5)=404
6http.Get(https://xnacly.me/about)=200

Go routines ##

Probably the most unique feature of go in comparison to other largely used programming languages is its concurrency model. Therefore lets add the ability to spawn go routines to c++.

 1package main
 2
 3import "C"
 4import (
 5	"fmt"
 6	"math"
 7	"net/http"
 8	"sync"
 9	"time"
10)
11
12// ...
13
14//export Routines
15func Routines(n int) {
16	wg := sync.WaitGroup{}
17	for i := range n {
18		wg.Add(1)
19		fmt.Printf("Spawning go routine %d\n", i)
20		go func() {
21			defer wg.Done()
22			time.Sleep(time.Millisecond * 10)
23		}()
24	}
25	wg.Wait()
26}
27
28// ...

Lets just add the Routines call to the c++ main function and invoke 1024 go routines:

1// ...
2int main() {
3  // ...
4  Routines(1024);
5}

After building and executing the binary we get:

1$ make
2go build -buildmode=c-archive -o lib.a lib.go
3g++ -Wall main.cpp lib.a -o main
4./main
5Spawning go routine 0
6...
7Spawning go routine 1023

Very many go routines :^).

There you have it, a nice and short explanation for calling go functions from c++ (if you need to). The same should work for c, but I didnt bother to test this one.