前言

在项目开发中，有时会使用到多种编程语言，比如部分功能是C/C++代码实现的，而另一部分是Python代码实现的，这样就可能需要使用多种编程语言。当然，也可以把C/C++代码转成Python，但这样可能费时；也有可能某个模块用Python来实现，速度很慢，但用C/C++速度却很快，这就会使用到用Python来调用C/C++代码。

本文主要说明如何使用Python来调用C/C++代码，且是基于Linux平台，Linux上编译生成动态共享库so文件，然后Python使用ctype模块来调用so文件里的函数。如果不同平台，比如Windows或者mac，编译的动态共享库文件是不一样的。

C/C++动态共享库编译

首先要把C/C++代码编译成动态共享库，一般是通过extern C来实现对外接口。下面给出一个例子。test.h文件进行函数声明，test.cpp是函数实现。

/******c动态库接口文件test.h*************/
#ifndef TEST_H
#define TEST_H

#ifdef __cplusplus
extern "C" {
#endif

    int hello();

#ifdef __cplusplus
}
#endif

#endif /* TEST_H */

/*****c动态库函数实现test.cpp*****************/
#include <stdio.h>
#include <iostream>
#include <string.h>
#include <stdlib.h>
#include "test.h"

int hello()
{
    printf("hello world\n");
    return 0;
}

编译命令为：g++ -std=c++11 -o libtest.so -shared -fPIC test.cpp。编译完成后，就会在当前路径下生成libtest.so文件。

ctype模块

通过ctype模块，可以加载动态库到进程中并返回其实例对象，该方法每次都会返回一个新实例，使用方法如下：

import ctypes

mylib = ctypes.cdll.LoadLibrary("libtest.so") #此次可能要加入绝对路径

ctype数据类型

因为ctypes只能调用C编译成的库，因此不支持重载，需要在程序中显示定义函数类型和返回值类型。ctypes基本数据类型如下：

在定义函数的参数和返回值时，必须使用ctypes的数据类型，若没有显示定义参数类型和返回类型，python默认为int型。参数类型用关键字argtypes定义，返回类型用restype定义，其中argtypes必须是一个序列，如tuple或者list，否则会报错，好像不使用参数类型关键字和返回类型也行。

使用案例

float数据

C/C++代码

float addfloat(float a, float b)
{
    printf("a = %f, b = %f \n", a, b);
    return a + b;
}

Python端代码

def c_basic_test():
    a = ctype.c_float(2.1)
    b = ctype.c_float(3.5)
    c = mylib.addfloat(a, b)
    print(c)

指针

从上面的表格中，我们可以看到char*和void*已经有专用类型了，直接使用即可，对于其他类型的指针，ctypes提供了两种定义方式pointer和POINTER。POINTER必须传入ctypes类型，创建出新的ctypes指针类型（pointer type），而pointer传入一个对象，创建出一个新的指针实例。（POINTER创建出了pointer）。

传输地址，ctypes提供了byref函数，ctypes.byref(obj[, offset])，该函数返回一个指向ctypes实例对象的轻量级指针，函数中还可以通过参数（必须是int）来设置偏移地址，这个返回的对象只能用于外部函数调用的参数。

C/C++代码

void pointerTest(int* pInt, float* pFloat)
{
    *pInt = 10;
    *pFloat = 12.34;
}

Python代码

def c_pointer_test():
    # 好像可有可无
    #library.pointerTest.argtypes = [POINTER(c_int), POINTER(c_float)]
    #library.pointerTest.restype = c_void_p
    a = 0
    b = 0
    int_a = ctype.c_int(a)
    float_b = ctype.c_float(b)

    # byref()函数用于传输地址
    mylib.pointerTest(byref(int_a), byref(float_b))
    print("out_a:", int_a.value)
    print("out_b", float_b.value)

外部传输字符空间，在函数内部进行赋值

C/C++代码

void mallocTest(char* pszStr)
{
    strcpy(pszStr, "Happay Children's day");
}

Python代码

def c_malloc_test():
    library.mallocTest.argtypes = [c_char_p]
    library.mallocTest.restype = c_void_p

    word = (c_char * 32)()
    mylib.mallocTest(word)
    print("out_word:", word.value)

结构体及结构体指针

结构体是C/C++中常用类型，使用前要先定义其成员类型，在python中也是同样处理，python中的结构体必须继承Structure类，定义其成员必须使用_field_属性。该属性是一个list，其成员都是2个值的tuple，分别是每个结构体成员的类型和长度，而且定义类型必须使用ctypes类型或者由ctype组合而成的新类型。而且结构体还存在嵌套的情况，这里也嵌套的结构体为例。

C/C++代码

struct sub_struct{
    char* test_char;
    int test_int;
};

struct struct_def {
    char* stru_string;
    int stru_int;
    char stru_arr_num[4];
    sub_struct son_struct;
};


int test(struct_def struct_mystruct, struct_def* struct_test_p) 
{
    //输出结构体指针的数据
    cout<<"输出结构体中的char*字符:";
    cout << struct_mystruct.stru_string << endl;
    cout<<"输出结构体中的int型：";
    cout << struct_mystruct.stru_int <<endl;
    cout <<"输出结构体中的字符数组:";
    for(int x = 0;x< 4;x++) {
        cout << struct_mystruct.stru_arr_num[x]<<"   ";
    }
    cout<< endl;
    cout<<"输出子结构体中的char*型：";
    cout << struct_mystruct.son_struct.test_char<<endl;
    cout<<"输出子结构体中的int型：";
    cout<<struct_mystruct.son_struct.test_int<<endl;
    //输出结构体指针的数据
    cout<<endl;
    cout<<endl;
    cout<<"输出结构体指针中的char*字符:";
    cout << struct_test_p->stru_string << endl;
    cout<<"输出结构体指针中的int型：";
    cout << struct_test_p->stru_int <<endl;
    cout <<"输出结构体指针中的字符数组:";
    for(int x = 0;x< 4;x++) {
        cout << struct_test_p->stru_arr_num[x]<<"   ";
    }
    cout<< endl;
    cout<<"输出子结构体指针中的字符串：";
    cout<<struct_test_p->son_struct.test_char;
    cout << endl;
    cout<<"输出子结构体指针中的int型：";
    cout<<struct_test_p->son_struct.test_int<<endl;
}

Python代码

class sub_struct(ctypes.Structure):
    _fields_ = [
        ("test_char_p",ctypes.c_char_p),
        ("test_int",ctypes.c_int)
    ]

class struct_def(ctypes.Structure):
    _fields_ = [
        ("stru_string",ctypes.c_char_p),
        ("stru_int", ctypes.c_int),
        ("stru_arr_num", ctypes.c_char*4),
        ("son_struct", sub_struct)
    ]

struct_mystruct = struct_def()
struct_mystruct.stru_string = b"string in the struct"
struct_mystruct.stru_int = 99
struct_mystruct.stru_arr_num = b"ABCD"
struct_mystruct.son_struct.test_char_p =b"sub struct of the string"
struct_mystruct.son_struct.test_int = 10
mylib.test(struct_mystruct,ctypes.byref(struct_mystruct))

numpy图像当作指针传入

在处理图像时，经常是传入一张图像，输出另外一张图像，图像处理部分是C/C++代码处理，这里也把彩色图像转出灰度图像为例。

C/C++代码

void GetGrayImage(unsigned char *rgb, unsigned char *gray, int width, int height)
{
    for(int j =0; j < height; j++) {
        for(int i = 0; i < width; i++) {
            int r = rgb[j * width + i];
            int g = rgb[j * width + i + width * height];
            int b = rgb[j * width + i + 2 * width * height];
            int val = 0.299 * r + 0.587 * g + 0.114 * b;
            gray[j * width + i] = val;
        }
    }
}

Python代码

    img = cv2.imread('1.jpg', 1)
    h, w, c = img.shape
    imgrgb = img[:, :, ::-1] # BGR2RGB
    imgrgb = np.transpos(img, (2, 0, 1)) # RGBRGB格式转成RRR  GGG  BBB
    imgrgb = imgrgb.reshape(1, -1)
    grayimg = np.zeros((h,w), np.uint8)
    grayimg = grayimg.reshape(1, -1)
    rgbdata = imgrgb.ctypes.data_as(ctypes.POINTER(ctypes.c_ubyte))
    graydata = grayimg.ctypes.data_as(ctypes.POINTER(ctypes.c_ubyte))
    width = ctypes.c_int(w)
    height = ctypes.c_int(h)
    mylib.GetGrayImage(rgbdata, graydata, width, height)
    grayimg = grayimg.reshape(h, w)
    cv2.imwrite('gray.jpg', grayimg)

暂且列了这些应用，一些没涉及到的，可能根据这些用例可以类似处理，之后如果遇到新的使用案例再新增。