├── Makefile
├── README.md
├── cfoo.cpp
├── foo.cpp
├── foo.go
├── foo.h
└── foo.hpp


/Makefile:
--------------------------------------------------------------------------------
 1 | .PHONY: clean
 2 | 
 3 | TARGET=howto-go-with-cpp
 4 | 
 5 | $(TARGET): libfoo.a
 6 | 	go build .
 7 | 
 8 | libfoo.a: foo.o cfoo.o
 9 | 	ar r $@ $^
10 | 
11 | %.o: %.cpp
12 | 	g++ -O2 -o $@ -c $^
13 | 
14 | clean:
15 | 	rm -f *.o *.so *.a $(TARGET)
16 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # Wrapping C++ with Go
2 | 
3 | This is a minimal example of how to wrap a C++ class manually with Go.
4 | 
5 | I borrowed most of the code from [a stack overflow answer](http://stackoverflow.com/questions/1713214/how-to-use-c-in-go),
6 | but modified it to use static linking.
7 | 
8 | 


--------------------------------------------------------------------------------
/cfoo.cpp:
--------------------------------------------------------------------------------
 1 | #include "foo.hpp"
 2 | #include "foo.h"
 3 | 
 4 | Foo FooInit() {
 5 | 	cxxFoo * ret = new cxxFoo(1);
 6 | 	return (void*)ret;
 7 | }
 8 | 
 9 | void FooFree(Foo f) {
10 | 	cxxFoo * foo = (cxxFoo*)f;
11 | 	delete foo;
12 | }
13 | 
14 | void FooBar(Foo f) {
15 | 	cxxFoo * foo = (cxxFoo*)f;
16 | 	foo->Bar();
17 | }
18 | 
19 | 


--------------------------------------------------------------------------------
/foo.cpp:
--------------------------------------------------------------------------------
1 | #include <iostream>
2 | #include "foo.hpp"
3 | 
4 | void cxxFoo::Bar(void) {
5 | 	std::cout<<this->a<<std::endl;
6 | }
7 | 
8 | 


--------------------------------------------------------------------------------
/foo.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | // #cgo LDFLAGS: -lfoo
 4 | // #include "foo.h"
 5 | import "C"
 6 | 
 7 | type GoFoo struct {
 8 | 	foo C.Foo
 9 | }
10 | 
11 | func New() GoFoo {
12 | 	var ret GoFoo
13 | 	ret.foo = C.FooInit()
14 | 	return ret
15 | }
16 | func (f GoFoo) Free() {
17 | 	C.FooFree(f.foo)
18 | }
19 | func (f GoFoo) Bar() {
20 | 	C.FooBar(f.foo)
21 | }
22 | 
23 | func main() {
24 | 	foo := New()
25 | 	foo.Bar()
26 | 	foo.Free()
27 | }
28 | 


--------------------------------------------------------------------------------
/foo.h:
--------------------------------------------------------------------------------
 1 | #ifndef _MY_PACKAGE_FOO_H_
 2 | #define _MY_PACKAGE_FOO_H_
 3 | 
 4 | #ifdef __cplusplus
 5 | extern "C" {
 6 | #endif
 7 | 
 8 | 	typedef void* Foo;
 9 | 	Foo FooInit(void);
10 | 	void FooFree(Foo);
11 | 	void FooBar(Foo);
12 | 
13 | #ifdef __cplusplus
14 | }
15 | #endif
16 | 
17 | #endif
18 | 


--------------------------------------------------------------------------------
/foo.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef _MY_PACKAGE_FOO_HPP_
 2 | #define _MY_PACKAGE_FOO_HPP_
 3 | 
 4 | class cxxFoo {
 5 | public:
 6 | 	int a;
 7 | 	cxxFoo(int _a):a(_a){};
 8 | 	~cxxFoo(){};
 9 | 	void Bar();
10 | };
11 | 
12 | #endif
13 | 


--------------------------------------------------------------------------------