use Swig to create C/C++ extension for Python

SWIG is a software development tool that simplifies the task of interfacing different languages to C and C++ programs.

1.  The SWIG %module directive specifies the name of the Python module
    --this module consists of a Python source file example.py and a low-level extension module _example.so.

2.  input is a interface file (*.i) or C/C++ header file,SWIG transforms it into a set of low-level procedural wrappers
     (module_wrap.cxx, which later compiled to be _module.so)
     Using these wrappers, SWIG generates a high-level Python proxy class (also known as a shadow class, in moudle.py)
     that is, file.i is transformed into a file file_wrap.c or file_wrap.cxx ; generate proxy class files in the target language

3.  Everything in the %{ ... %} block is simply copied verbatim to the resulting wrapper file created by SWIG.
     (the included staff are need to compile module_wrap.cxx)

4.  %immutable directive stays in effect until it is explicitly disabled or cleared using %mutable.(vars with const decorator)

5.  To create a constant, use #define, enum , or the %constant directive

6.  Global functions are wrapped as new Python built-in functions.

7.  SWIG creates a special object called `cvar' that is added to each SWIG generated module.
     Global variables are then accessed as attributes of this object.

8.   Most of SWIG's operation is controlled by special directives that are always preceded by a "%"
     to distinguish them from normal C declarations

9.  all variable declarations, regardless of any use of const, are wrapped as global variables.
     If a declaration happens to be declared as const, it is wrapped as a read-only variable

10. It'a a bad idea to pass a string from scripting language to C char * (of which the value is possible to be changed),
      for in python, string is a tuple (const!!)

11. except the basic types, For everything else (structs, classes, arrays, etc...) SWIG applies a very simple rule :
      Everything else is a pointer

12. Arrays are fully supported by SWIG, but we need to create extra helper function

13. director feature can used to realize polymorphism

14. the code inside an %inline %{... %} block is given to both the C compiler and SWIG

Exmaple:

// file:llist.h
class llist
{
public:
    int getvalue();
    void setvalue(int a);
    int value;
};

class llistA:public llist
{
    public:
    void printt(llist a);
    void printt(llist* a);
};

struct Vector {
int a;
};

/* file: example.h */
#define MAXAA 6
int Foo;
char * path = "hello";
int fact(int n);
double cal(double X);

#include "llist.h"
#include "example.h"
#include <iostream>
using namespace std;

int fact(int n)
{
    if (n < 0) return 0;
    if (n == 0) return 1;
    else return n* fact(n-1);
}

double cal(double x)
{
    Foo += (int)x * MAXAA;
    return x *2;
};

void strprint(const char * s, int a)
{
    cout << s << " with int value: " << a << endl;
}

llist getlist(Vector &vecta, llist * b)
{
    b->setvalue(vecta.a+b->getvalue());
    return *b;
}

int  llist::getvalue() { return this->value;}
void llist::setvalue(int a) { this->value = a;}
void llistA::printt(llist a) { cout << "llistA a" << endl;}
void llistA::printt(llist* a) { cout << " pointer of llistA a " << endl;}

// file :  example.i

%module example
%{
// the following macro will insert module init code in moudle_wrap.cxx
#define SWIG_FILE_WITH_INIT

#include "llist.h"

extern int Foo;
extern char * path;

int fact(int n);
double cal(double X);
void strprint(const char *, int a);
llist getlist(Vector& vecta, llist * b);
%}

extern int Foo;
%immutable;
extern char * path;
%mutable;
%constant const char * brig = "/usr/local";

class llist
{
public:
    int getvalue();
    void setvalue(int a);
    int value;
};

class llistA:public llist
{
    public:
    void printt(llist a);
    void printt(llist* a);
};

class Vector {
int a;
};

int fact(int n);
double cal(double X);
void strprint(const char *, int a);
llist getlist(Vector& vecta, llist * b);

to build it (bash):

#------------------C------------------------------
#swig -python example.i
#python setup.py build_ext --inplace
#
#----------------C++----------------------------
swig -c++ -python example.i
g++ -O2 -fPIC -c example.cpp
g++ -O2 -fPIC -c example_wrap.cxx -I/usr/include/python3.5m
g++ -shared example.o example_wrap.o -o _example.so

test code:

#!/usr/bin/env python
import example
print("call function fact: ", example.fact(5))
print("call function cal : ", example.cal(4.5))
print("print global value: ", example.cvar.Foo)
example.cvar.Foo = 6;
example.cal(1)
print("print global value Foo : ", example.cvar.Foo)
print("print global value path: ", example.cvar.path)
print(example.cvar.brig)
#print(example.cvar.MAXAA)
# be careful, it's "vetor()" not "vector"
v = example.Vector()
v.a = 5;
list = example.llist()
list.value = 6
lista = example.llistA()
lista.setvalue(8)
print("call member fuction of llistA")
lista.printt(list)
lista.printt(lista)
print("vector v : ", v)
print("class list  : ", list)
print("class listA : ", lista)
listc = example.getlist(v, list)
print("instnce listc : ", listc)
print("value of listc: ", listc.getvalue())