How to write a DLL/SO in C/C++ for Python

This article explains how to write a DLL/SO in C/C++ for Python

Note: Cython can also be used to create and wrap C libraries for Python, and might be a good alternative to the approach explained in this article.

Create a new file and write, for example, a function that sums two numbers and returns the result.

If you are using C call the file test.c and write:
```
//test.c
__declspec(dllexport) int sum(int a, int b) {
    return a + b;
}
```
If you are using C++ call the file test.cpp and write:
```
//test.cpp
#define DLLEXPORT extern "C" __declspec(dllexport)

DLLEXPORT int sum(int a, int b) {
    return a + b;
}
```
If you are using Windows, __declspec(dllexport) is necessary to add the export directive to the object file and make the function accessible without using a .def file. If you are using Linux it can be omitted.

The extern "C" construct prevents the compiler to add decorations on the functions' names in the DLL/SO and it is necessary while using C++.

Note: in order to make the code more readable and avoid repetitions, it is a good idea to use a #define as shown in the example
The header of the function can be added to test.h (but it's not necessary):
```
//test.h
int sum(int, int);
```
Compile the program to obtain a DLL/SO.

If you are using Windows and Visual Studio, create a new Dinamic-Link Library project and include the two files.

Another way is to use the cl program located in the Visual Studio directory (e.g. C:\Programs\Microsoft Visual Studio 8\VC) with the /LD option:
```
>cl /LD test.c
[...]
/out:test.dll
/dll
/implib:test.lib
test.obj
   Creating library test.lib and object test.exp
```
Note: cl use the file extension (.c or .cpp) to know if the source is written in C or C++.

If you are using Linux, you can use gcc/g++ to compile the program and create the .so:
```
gcc -Wall -Wextra -O -ansi -pedantic -shared test.c -o test.so
```
Note: the -shared option is responsible to create the .so.

Note: You can also use Dependency Walker or similar programs to see the list of the exported functions and check if the sum function is there.
Use the ctypes module to access the DLL:
```
>>> from ctypes import cdll
>>> mydll = cdll.LoadLibrary('test.dll')
>>> mydll
<CDLL 'test.dll', handle 10000000 at b92310>
```
On Windows, cdll.LoadLibrary will search for the DLL in the CWD. On Linux instead, it is necessary to provide the path too:
```
>>> from ctypes import cdll
>>> mydll = cdll.LoadLibrary('/home/wolf/test.so')
>>> mydll
<CDLL '/home/wolf/test.so', handle 9ba7d30 at b7e55d2c>
```
Note: ctype module is already included from Python 2.5. If you are using an older version you can download ctypes here.

We can now use mydll to access the sum function:

>>> mydll.sum
<_FuncPtr object at 0x00AF6918>
>>> mydll.sum(5, 3)
8