python调用c++动态库_python 调用c++动态库 - CSDN
精华内容
参与话题
  • python调用C/C++动态库

    2019-09-03 18:26:05
    目录 1. 背景知识 1.1 动态链接库 1.2 extern "C"作用 1.3 动态链接库加载方式 1.3.1 隐式链接 1.3.2 显式链接 2. python操作动态库 2.1 加...

    本文以windows环境下的.dll动态链接库为背景展开,有关linux下的.so动态链接库的相关用法会在另外一篇文章中展开讲解。

    1. 背景知识

    一直以来python都被称为胶水语言,能够轻易地操作其他程序,轻易地包装使用其他语言编写的库。下面简单介绍下如何使用python来调用C/C++编写的动态库。首先了解下动态链接库及C/C++动态库的区别。

    1.1 动态链接库

    使用VS2017创建动态链接库DllDemo,代码如下:

    //整型相加
     __declspec(dllexport) int addInt(int a, int b) 
    {
        return a + b;
    }
    //浮点型相加
    __declspec(dllexport) float addFloat(float a, float b) 
    {
        return a + b;
    }
    //传递float指针类型参数
    __declspec(dllexport) void changeFloat(float *a) 
    {
        *a = 100.00;
    }
    //传递char指针类型参数,返回指针类型参数
    __declspec(dllexport) char* pointCh(char *a) 
    {
        return a;
    }

    使用dumpbin.exe工具,在cmd命令行使用

    dumpbin.exe -exports DllDemo.dll

    查看动态库的导出函数如下:
    1108707-20190127201915680-1462619078.png

    从上图可以看出动态库导出了4个函数,与上面代码中的导出函数一致。但是函数名长得很奇怪,这是因为在编译链接时,C++会按照自己的规则篡改函数的名称,这一过程称为"名字改编",C++支持函数重载,就是在函数名字改编阶段记录下函数的相关参数信息。

    C++标准并没有定义名字改编的标准,因此会导致不同编译器编译出来的动态库不能通用。

    1.2 extern "C"作用

    相比之下,C标准规定了名字改编的标准,extern "C"指示编译器在编译代码是按照C的标准进行编译。
    在上述代码的每个函数名前都加上extern "C"关键字。

    extern "C" __declspec(dllexport) int addInt(int a, int b) 
    {
        return a + b;
    }
    
    extern "C" __declspec(dllexport) float addFloat(float a, float b) 
    {
        return a + b;
    }
    
    extern "C" __declspec(dllexport) void changeFloat(float *a) 
    {
        *a = 100.00;
    }
    
    extern "C" __declspec(dllexport) char* pointCh(char *a) 
    {
        return a;
    }

    查看动态库的导出函数,可以看到导出的函数名和函数的定义是一致的。
    1108707-20190127201954612-633386067.png

    如果extern "C"修饰的函数进行了重载,则会在编译时报错,因为C语言并不支持函数的重载。

    1.3 动态链接库加载方式

    1.3.1 隐式链接

    隐式链接需要.dll .lib文件

    #include <iostream>
    #include <Windows.h>
    using namespace std;
    
    //隐式加载需要导入动态库的导入库
    #pragma comment(lib, "../Debug/DllDemo.lib")
    
    //dll中导出的函数通过直接声明或者包含头文件的方式
    extern "C" _declspec(dllimport) int addInt(int a, int b);
    extern "C" _declspec(dllimport) float addFloat(float a, float b);
    
    int main()
    {
        //调用动态库中的函数
        cout << addInt(1, 2) << endl;
        cout << addFloat(1.25, 2.25) << endl;
    }

    通过vs自带的工具lib,通过命令lib /list XXXX.lib,可以查看一个.lib文件是静态库还是导入库

    1.3.2 显式链接

    显式链接需要.dll, 需要事先知道导出函数的签名,不需要.lib和.h文件

    #include <iostream>
    #include <Windows.h>
    using namespace std;
    
    //声明导出函数的类型
    typedef int(*addInt)(int a, int b);
    typedef float(*addFloat)(float a, float b);
    
    int main()
    {
        HINSTANCE hDLL;
    
        //定义导出函数
        addInt addInt_;
        addFloat addFloat_;
        
        //加载动态库,开辟内存
        hDLL = LoadLibrary("./DllDemo.dll");
        if (hDLL != NULL)
        {
            //获取导出函数
            addInt_ = (addInt)GetProcAddress(hDLL, "addInt");
            if (addInt_)
            {
                cout << addInt_(1, 2) << endl;
            }
    
            addFloat_ = (addFloat)GetProcAddress(hDLL, "addFloat");
            if (addFloat_)
            {
                cout << addFloat_(1.25, 2.25) << endl;
            }
            //卸载动态库,释放内存
            FreeLibrary(hDLL);
        }
    
        return 0;
    }

    使用显式加载的好处:

    • 通过显式加载动态库的方式可以根据需要加载相应的函数,随时可以卸载,通过判断句柄的方式,不会因为找不到dll导致程序无法启动。
    • 如果程序需要访问十多个dll,采用动态加载的方式可以减少程序的启动时间,减小程序占用的内存

    2. python操作动态库

    python操作动态库是通过ctypes这个内建的包,官方文档ctypes。因为上述C++动态库“名字改编”的问题,导致直接使用C++代码中函数名字时无法调用,必须使用经过名字改编之后的函数名,在使用C++编译的动态链接库时,最好使用extern "C"来辅助,可以通过对C++动态库进行简单的封装转换为C动态库,这样可以在使用时直接调用动态库中定义的函数即可,不需要考虑函数“名字改编”的问题。

    先上代码:

    #--*--utf8--*--
    from ctypes import *
    
    # 加载动态库
    Objdll = cdll.LoadLibrary('DllDemo.dll')
    
    def dllTest():
        # python调用动态库默认参数为整型
        print(Objdll.addInt(10, 20))
        
        # 直接调用addFloat接口
        print(Objdll.addFloat(10, 2))
    
        # 设置动态库函数的参数和返回值类型为float
        Objdll.addFloat.restype = c_float
        Objdll.addFloat.argtypes = (c_float, c_float)
        print(Objdll.addFloat(10.0, 20.0))
    
        # 设置动态库的参数类型float*
        infloat = c_float(1.0)
        Objdll.changeFloat.restype = None
        Objdll.changeFloat.argtypes = (POINTER(c_float), )
        Objdll.changeFloat(byref(infloat))
        print(infloat.value)
    
        # 设置动态库的参数类型为char*
        pInCh = bytes('Hello World', 'utf-8')
        Objdll.pointCh.restype = c_char_p
        Objdll.pointCh.argtypes = (c_char_p, )
        pOutCh = Objdll.pointCh(pInCh)
        print(pOutCh.decode('utf-8'))
    
    if __name__ == "__main__":
        dllTest()

    代码输出:

    1108707-20190127202156609-456267278.png

    2.1 加载动态库

    Objdll = cdll.LoadLibrary('DllDemo.dll')

    2.2 指定函数命名

    查看在上图中直接调用addFloat的代码输出

        # 直接调用addFloat接口
        print(Objdll.addFloat(10, 2))

    发现输出的结果并不是预期的12.0而是一个特别大的数字,这是因为python在调用动态库的函数时,如果不进行指定,则默认的参数类型和返回值类型均为整型,且调用时不会像在C/C++中一样进行自动的类型转换。python在调用动态库中的函数时需要指定函数的参数类型和返回值类型。

    通过Objdll._FuncPtr.restype来指定动态库函数的返回值类型,通过Objdll._FuncPtr.argtypes来指定动态库函数的参数类型,Objdll._FuncPtr.argtypes的类型为turple,包含动态库函数的参数类型列表,指定的参数类型必须为C/C++中参数类型所对应的ctypes类型。

    2.3 参数类型

    python类型和C语言类型的对应关系:

    ctypes type C type python type
    c_bool _Bool bool (1)
    c_char char 1-character bytes object
    c_wchar wchar_t 1-character string
    c_byte char int
    c_ubyte unsigned char int
    c_short short int
    c_ushort unsigned short int
    c_int int int
    c_uint unsigned int int
    c_long long int
    c_ulong unsigned long int
    c_longlong __int64 or long long int
    c_ulonglong unsigned __int64 or unsigned long long int
    c_size_t size_t int
    c_ssize_t ssize_t or Py_ssize_t int
    c_float float float
    c_double double float
    c_longdouble long double float
    c_char_p char * (NUL terminated) bytes object or None
    c_wchar_p wchar_t * (NUL terminated) string or None
    c_void_p void * int or None

    2.3.1 值类型

    对于参数类型和返回值类型都为值类型的动态库函数,操作相对简单,只需要指定对应的参数和返回值ctype类型即可进行调用。

    2.3.2 指针类型

    创建ctypes类型的指针需要借助三个相关的函数:

    函数 说明
    byref(x[,offset]) 返回x的地址,相当于C的&x。可选参数offset表示偏移量
    pointer(x) 创建并返回一个指向x的指针实例,x是一个实例对象
    POINTER(x) 返回一个类型,这个类型是指向ctypes类型的指针类型

    byref相当于C的取地址符号,在参数传递时可以通过byref传递函数的指针。pointerPOINTER的区别是,pointer返回的是一个实例,而POINTER返回的是一个类型。

    动态库函数原型:

    extern "C" __declspec(dllexport) void changeFloat(float *a) 
    {
        *a = 100.00;
    }

    python中调用:

    # 加载动态库
    Objdll = cdll.LoadLibrary('DllDemo.dll')
    
    # 定义函数参数
    infloat = c_float(1.0)
    
    # 指定函数返回值类型为void
    Objdll.changeFloat.restype = None
    
    # 指定函数的参数类型为float*
    Objdll.changeFloat.argtypes = (POINTER(c_float), )
    
    # 调用函数,通过byref函数将参数包装成float*类型
    Objdll.changeFloat(byref(infloat))
    
    # 打印结果
    print(infloat.value)

    2.3.3 引用类型

    C语言中没有引用类型,如果动态库是由C++编写存在引用类型参数的函数,需要先用指针类型包装成C动态库。

    2.3.4 结构体类型

    动态库函数定义:

    typedef struct _SimpleStruce
    {
        int nNo;
        float fVirus;
        char szBuffer[512];
    }SimpleStruct, *PSimpleStruct;
    
    extern "C" __declspec(dllexport) int PrintStruct(PSimpleStruct simp)
    {
        cout << "nNo: " << simp->nNo << ", fVirus: " << simp->fVirus << ", szBuffer: " << simp->szBuffer << endl;
        return simp->nNo;
    }

    python中调用

    # 定义class和动态库中的类型相对应,成员变量名必须一致
    class SimpStruct(Structure):
        _fields_ = [("nNo", c_int), ("fVirus", c_float), ("szBuffer", c_char*512)] 
    
    # 定义变量,并对各个成员变量名进行赋值
    simpStruct = SimpStruct()
    simpStruct.nNo = 16
    simpStruct.fVirus = 3.14
    simpStruct.szBuffer = bytes('Hello World','utf-8')
    
    # 定义函数的参数和返回值
    Objdll.PrintStruct.restype = c_int
    Objdll.PrintStruct.argtypes = (POINTER(SimpStruct),)
    
    # 调用动态库函数,传递结构体指针
    resnNo = Objdll.PrintStruct(byref(simpStruct))
    
    # 打印动态库函数返回值
    print(resnNo)

    python调用结果:

    nNo: 16, fVirus: 3.14, szBuffer: Hello World
    16

    3.总结

    总结起来,在python中调用dll中方法的一般步骤为:

    1. 使用extern c关键字对dll进行包装。
    2. 使用ctypes库加载动态库。
    3. 根据C中类型和ctypes中类型的对应关系指定动态库函数的返回值类型和参数类型。
    4. 调用动态库中的函数。
    5. 对函数的返回结果进行转换成python中的类型进行使用。
    展开全文
  • Python调用C/C++动态链接的需求在自动化测试过程中,难免会遇到语言混合使用的情况,这不,我们也遇到了。初步决定采用Robot Framework作为自动化测试框架后,其支持Java和Python,而Python作为主流的语言,怎么能...

    Python调用C/C++动态链接库的需求

    在自动化测试过程中,难免会遇到语言混合使用的情况,这不,我们也遇到了。初步决定采用Robot Framework作为自动化测试框架后,其支持Java和Python,而Python作为主流的语言,怎么能放弃使用它的机会^_^。 然而产品采用是古老90年代开发的C/S结构,因为古老,当时也没有考虑到对产品的测试进行自动化,Client端并没有预留CLI(Command Line interface)形式的接口,真是雪上加霜啊。

    那怎么自动化?采用AutoIT来对客户端界面进行自动化测试?可惜AutoIT对当初开发采用的控件识别不是很好,如果采用控件所在位置来进行控制的方式,又会导致自动化测试并不是很稳定。那么!!!只有自己开发接口了,目前在Client端开发出CLI形式的接口,将其封装为DLL,然后在Robot FrameWork框架中采用Python对DLL进行调用。任务艰巨哪!


    Python调用DLL例子


    示例一

    首先,在创建一个DLL工程(本人是在VS 2005中创建),头文件:

    1. //hello.h  
    2. #ifdef EXPORT_HELLO_DLL  
    3. #define HELLO_API __declspec(dllexport)  
    4. #else  
    5. #define HELLO_API __declspec(dllimport)  
    6. #endif  
    7.   
    8. extern "C"  
    9. {  
    10.     HELLO_API int IntAdd(int , int);  
    11. }  

    CPP文件:

    1. //hello.cpp  
    2. #define EXPORT_HELLO_DLL  
    3. #include "hello.h"  
    4.   
    5. HELLO_API int IntAdd(int a, int b)  
    6. {  
    7.     return a + b;  
    8. }  

    这里有两个注意点:

    (1)弄清楚编译的时候函数的调用约定采用的__cdecl还是__stdcall,因为根据DLL中函数调用约定方式,Python将使用相应的函数加载DLL。

    (2)如果采用C++的工程,那么导出的接口需要extern "C",这样python中才能识别导出的函数。

    我的工程中采用__cdecl函数调用约定方式进行编译链接产生hello.dll,然后Python中采用ctypes库对hello.dll进行加载和函数调用:

    [python] view plain copy
    1. from ctypes import *  
    2. dll = cdll.LoadLibrary('hello.dll');  
    3. ret = dll.IntAdd(24);  
    4. print ret;  

    OK,一个小例子已经完成了,如果你感兴趣,但还没试过,那就尝试一下吧。

    示例二

    示例一只是一个"hello world"级别的程序,实际运用中更多的需要传递数据结构、字符串等,才能满足我们的需求。那么这个示例将展示,如何传递数据结构参数,以及如何通过数据结构获取返回值。

    首先编写DLL工程中的头文件:

    1. //hello.h  
    2. #ifdef EXPORT_HELLO_DLL  
    3. #define HELLO_API __declspec(dllexport)  
    4. #else  
    5. #define HELLO_API __declspec(dllimport)  
    6. #endif  
    7.   
    8. #define ARRAY_NUMBER 20  
    9. #define STR_LEN 20  
    10.   
    11. struct StructTest  
    12. {  
    13.     int number;  
    14.     char* pChar;  
    15.     char str[STR_LEN];  
    16.     int iArray[ARRAY_NUMBER];  
    17. };  
    18.   
    19. extern "C"  
    20. {  
    21.     //HELLO_API int IntAdd(int , int);  
    22.     HELLO_API char* GetStructInfo(struct StructTest* pStruct);  
    23. }  

    CPP文件如下:

    1. //hello.cpp  
    2. #include <string.h>  
    3. #define EXPORT_HELLO_DLL  
    4. #include "hello.h"  
    5.   
    6. HELLO_API char* GetStructInfo(struct StructTest* pStruct)  
    7. {  
    8.     for (int i = 0; i < ARRAY_NUMBER; i++)  
    9.         pStruct->iArray[i] = i;  
    10.   
    11.     pStruct->pChar = "hello python!";  
    12.   
    13.     strcpy (pStruct->str, "hello world!");  
    14.   
    15.     pStruct->number = 100;  
    16.   
    17.     return "just OK";  
    18. }  

    GetStructInfo这个函数通过传递一个StructTest类型的指针,然后对对象中的属性进行赋值,最后返回"just OK".

    编写Python调用代码如下,首先在Python中继承Structure构造一个和C DLL中一致的数据结构StructTest,然后设置函数GetStructInfo的参数类型和返回值类型,最后创建一个StructTest对象,并将其转化为指针作为参数,调用函数GetStrcutInfo,最后通过输出数据结构的值来检查是否调用成功

    [python] view plain copy
    1. from ctypes import *  
    2.   
    3. ARRAY_NUMBER = 20;  
    4. STR_LEN = 20;  
    5. #define type  
    6. INTARRAY20 = c_int * ARRAY_NUMBER;  
    7. CHARARRAY20 = c_char * STR_LEN;  
    8. #define struct  
    9. class StructTest(Structure):  
    10.     _fields_ = [  
    11.         ("number", c_int),  
    12.         ("pChar", c_char_p),  
    13.         ("str", CHARARRAY20),  
    14.         ("iArray", INTARRAY20)  
    15.                ]  
    16.   
    17. #load dll and get the function object  
    18. dll = cdll.LoadLibrary('hello.dll');  
    19. GetStructInfo = dll.GetStructInfo;  
    20. #set the return type  
    21. GetStructInfo.restype = c_char_p;  
    22. #set the argtypes  
    23. GetStructInfo.argtypes = [POINTER(StructTest)];  
    24.   
    25. objectStruct = StructTest();  
    26. #invoke api GetStructInfo  
    27. retStr = GetStructInfo(byref(objectStruct));  
    28.   
    29. #check result  
    30. print "number: ", objectStruct.number;  
    31. print "pChar: ", objectStruct.pChar;  
    32. print "str: ", objectStruct.str;  
    33. for i,val in enumerate(objectStruct.iArray):  
    34.     print 'Array[i]: ', val;  
    35. print retStr;  

    总结

    1. 用64位的Python去加载32位的DLL会出错

    2. 以上只是些测试程序,在编写Python过程中尽可能的使用"try Except"来处理异常

    3. 注意在Python与C DLL交互的时候字节对齐问题

    4. ctypes库的功能还有待继续探索

    展开全文
  • Python调用C++ 编写的dll动态库函数

    万次阅读 热门讨论 2018-08-04 19:50:15
    前两篇博客是c++调用python程序: ...一丶C++ 编译类动态库 ------------ **1)新建生成.dll文件的空项目** ![这里写图片描述](https://img-blog.csdn.net/20180730165252513?watermark/2/text/a...

    前两篇博客是c++调用python程序:
    C++调用Python函数(二)——调用函数并输出返回值
    C++调用Python函数(一)——配置及测试

    一丶C++ 编译类动态库

    1)新建生成.dll文件的空项目
    这里写图片描述
    双击:
    这里写图片描述
    2)编写头文件:pycall.h

    //test.h
    #pragma once
    class Mymath {
        int sum(int, int);
        int sub(int, int);
    };
    

    注:#define DLLEXPORT extern “C” __declspec(dllexport)
    1. windows下需要使用__declspec(dllexport)的声明来说明这个函数是动态库导出的
    2.extern “C”声明避免编译器对函数名称进行name mangling,这对于使用C++来编写DLL/SO是必须的。

    3)编写实现文件:pycall_so.cpp

    #define DLLEXPORT extern "C" __declspec(dllexport)
    #include"pycall.h"
    //两数相加
    DLLEXPORT int  sum(int a, int b) {
        return a + b;
    }
    //两数相减
    DLLEXPORT int sub(int a, int b) {
        return a-b;
    }

    然后生成解决方案:
    这里写图片描述
    生成了动态链接库和静态链接库

    二丶python利用Ctypes调用C++动态库

    把刚才生成的动态链接库放到.py文件夹下:

    import ctypes
    import os
    CUR_PATH=os.path.dirname(__file__)
    dllPath=os.path.join(CUR_PATH,"mydll.dll")
    print (dllPath)
    #mydll=ctypes.cdll.LoadLibrary(dllPath)
    #print mydll
    pDll=ctypes.WinDLL(dllPath)
    print (pDll)
    
    pResutl= pDll.sum(1,4)
    pResult2=pDll.sub(1,4)
    print (pResutl)
    print (pResult2)

    输出5和-3.
    成功!!!

    参考:
    1.https://blog.csdn.net/adeen/article/details/49759033
    2.https://blog.csdn.net/dongchongyang/article/details/52926310

    展开全文
  • Python调用C/C++动态库

    2018-07-13 18:10:51
    https://blog.csdn.net/qq_37968132/article/details/79747070
    展开全文
  • 这篇文章主要介绍了Python调用C/C++动态链接的方法,需要的朋友可以参考下 本文以实例讲解了Python调用C/C++ DLL动态链接的方法,具体示例如下: 示例一: 首先,在创建一个DLL工程(本例创建环境为VS 2005),...
  • Python调用c/c++动态库(一)

    千次阅读 2020-08-31 10:37:27
    因为工作需求,最近要使用python在linux环境下调用c/c++动态库,执行动态库中的函数。这种没接触过的内容,自然首先开启百度谷歌大法。经过一番搜索,尝试使用python的ctypes模块。 一、初识 首先自然是查询...
  • 接下来我将实现用python的ctypes,调用c++动态库 导入python的必要库 import ctypes import cv2 import os from time import sleep os.environ["CUDA_VISIBLE_DEVICES"]="0" from ctypes import * 使用...
  • 真心日了狗,有一个c#的dll,python无法直接调用c#的dll,于是想先让c++调用c#的dll,但是这需要使用c++/cli来实现,那么这样生成的c++/cli的dll,python能否调用。。。
  • python 3 调用c/c++ 动态链接 *.dll

    千次阅读 2016-11-16 21:45:26
    首先,创建动态链接(一个简单的北斗数据处理接口,为简化处理,实现部分直接返回值),代码如下: #ifndef _pro_header_2014_ #define _pro_header_2014_ #ifdef EXPORT_PRO_DLL #define PRO_API __declspec(dll...
  • python调用so

    万次阅读 2013-03-27 00:57:13
    我厂大部分的code都是采用C++写的,有的时候需要进行一些数据分析,又需要用c++里面的很多函数,例如url的转换函数,hash编码的函数,着实不甚方便,这个时候把常用的c++的函数,封装为SOpython调度就非常有必要...
  • linux下python调用C++动态库以及库函数

    千次阅读 2018-03-21 17:51:39
    C++:首先C++需要编译成动态共享库C++代码(cpptest.cpp)如下------#include&lt;iostream&gt;using namespace std;extern "C"{//在extern “C”中的函数才能被外部调用int test(){ cout&lt;&...
  • python调用动态链接C++,DLL)

    千次阅读 2017-07-04 15:21:22
    动态链接编译 使用VS2015创建“Win32项目”,选择应用程序类型为“DLL”,创建项目完成后,头文件中: #ifdef EXT_DEC_EXPORTS #define EXT_DEC_API __declspec(dllexport) #else #defineEXT_...
  • Python调用C++代码

    千次阅读 2018-09-07 06:13:23
    Python调用C++代码 今天在研究PyTorch中Tensor的一些操作的时候,发现其底层Tensor的操作都是用C++写的,并使用pybind11进行C++和Python的桥接。所以,我就想着探索一下Python中如何调用C++代码? 可行方案 ...
  • python如何调用c语言

    千次阅读 2017-08-14 17:52:35
    1、Python调用C动态链接  Python调用C比较简单,不经过任何封装打包成so,再使用python的ctypes调用即可。 (1)C语言文件:pycall.c /***gcc -o libpycall.so -shared -fPIC pycall.c*/ #include #...
  • 问题是:通过C++ 程序生成 DLL 内部使用了STL 等模板以及指针和引用。通过ctypes 模块给python ...我在python程序中已经指定了动态链接调用函数的 调用约定、函数返回类型以及函数形参类型。现在可能存在的问题...
  • 上一篇博客介绍了如何配置C++调用Python环境: C++调用Python环境配置 调用Python函数hello.py: def add_num(a,b): return a+b C++调用Python: #include &amp;lt;Python.h&amp;gt; #include&...
  • 注意:此生成的动态链接必须cdll.LoadLibrary('/home/leo/test.so'),不能直接import test 1. 新建一个源码文件,里面包含了返回两个整数的和的函数 如果使用C语言,新建test.c文件,并输入以下内容: // test.c...
  • 看到一篇简洁的文章--如何用Python ctypes调用C++(ctypes调用C没这么多麻烦事),不敢独享... 如果需要用 Python 调用 C/C++ 编写的第三方(这些第三方很可能就是你之前写出来的),只是需要一个脚本语言来...
  • python 调用 C++ code

    万次阅读 2015-10-24 02:33:10
    1. 如果没有参数传递从python传递至C++,python调用C++的最简单方法是将函数声明为C可用函数,然后作为C code被python调用,如这里三楼所示; 2. 有参数传递至C++函数,swig是最便捷的调用方法,以下面这个工程所示...
  • 因为算法效率问题所以要在python调用C,  先写一个C函数: cc.cpp: int ts(int a, int b) {  return a * b; } 编译 :  g++ -c -fPIC cc.cpp  g++ -shared cc.o -o libcc.so 然后在...
1 2 3 4 5 ... 20
收藏数 30,421
精华内容 12,168
关键字:

python调用c++动态库