MFC动态链接库的调用，有好多种方式，这里只介绍一种简单的调用的方式，只需要把动态链接库编译后的.dll文件放到调用界面的Debug下面。再在界面需要调用动态链接库里添加相关函数就行了。找了好多资料，发现没有详细的介绍，下面就是从动态链接库建立开始，一点点详细的介绍。

首先是，动态链接库的建立。我们这里讲的是MFC的标准库的建立。用的是vs2010。
我们建立一个名为TestDLL的动态链接库。

然后，我们这里实现一个小程序，在动态链接库里返回四个点，用来画一个矩形。

首先，我们写的是动态链接库里的内容，先不考虑界面的问题。

我们在动态链接库里新建一个类，用来储存矩形的四个点。注意，这里的类名不要起的很常见，例如，CDrawRect这样的类，因为很有可能和MFC内部已有的类冲突，从而会出现显示调用不明确的情况。

上面出现的warning“找不到符号唯一的匹配项错误”，是因为在mfc中已经有定义。

所以，我们起类名字时，要注意这点。

然后，我们在新建的类中添加一个公有成员函数，名字叫做

CPoint* GetPoint();

这样，就建立一个函数，里面返回的是矩形的点的数组的指针。这样，就能通过地址来调用数组里面的一串值了。

在.cpp里，写下：

CPoint* CDrawRectPoint::GetPoint()
{
    CPoint getPoint[4];

    getPoint[0].x=100;
    getPoint[0].y=100;
    getPoint[1].x=100;
    getPoint[1].y=500;
    getPoint[2].x=500;
    getPoint[2].y=500;
    getPoint[3].x=500;
    getPoint[3].y=500;

    return getPoint;
}

这里，我们为了养成一个良好的习惯，要把动态链接库的接口专门在一个派生类中写出来，这样，就会在导出的时候，我们只需要对接口进行处理就好了。并且，在提交项目时，也只需要提供.dll和接口类就好，可以有效的保证自己代码的安全和核心代码的利益。

于是，我们新建一个派生类，从CDrawRectPoint类里派生出来一个类，名字叫做CDrawRectPointIO。

#include "drawrectpoint.h"

class CDrawRectPointIO:
    public CDrawRectPoint
{
    //说明：没有把构造函数析构函数写出来
    CPoint* GetPoint();
}

在.cpp里：

CPoint* CDrawRectPointIO::GetPointIO()
{
    return GetPoint();
}

好了，上面是动态链接库里的内容已经写出来，下面是写出动态链接库的调出。

在CDrawRectPointIO.h文件中，在最开始的部分，加上：

//即把导出的函数声明为全局的,并且声明为外部可调用
extern "C" __declspec(dllexport)CPoint* __stdcall GetPointIO();

然后，再在源文件里的.def文件里，添加导出的函数的名称，因为这个是不加变量，只有函数名称的，所以，这也是前面提到的为什么函数命名时尽量不要用太常见的函数名的原因。

之后是调试，在Debug里得到.dll。到这里就是动态链接库的导出过程。

然后是动态链接库在界面中的调用。

新建一个MFC单文档类。名字叫做TestEXE，设置成MFC标准。这里为了方便画，直接就在OnDraw(CDC*pDC)函数里写了，实际上不推荐在这个函数里调用动态链接库，因为系统里会不断的自动刷新OnDraw()函数，所以，为了安全起见，我们最好不要用在OnDraw()函数里写。这里，我们用一个控制变量来控制是否启用动态链接库。

首先，是建立之后，F5调试程序。生成Debug，把前面动态链接库生成的.dll复制粘贴到界面的Debug里。

在资源视图里的Menu里添加菜单栏，并把ID修改。类向导到view里。

在view.h里添加成员变量，int m_nControl;在构造函数里初始化为0。

在view.cpp里，对刚才添加的OnRect()函数里，添加控制变量。

void CTestEXEView::OnRect()
{
    // TODO: 在此添加命令处理程序代码
    m_nControl = 1;
    Invalidate();
}

下面先是对动态链接库的调用，在view.cpp里，在文件头下添加如下：

typedef CPoint*(WINAPI *dllDraw)();

在OnDraw里添加：

if(1 == m_nControl)
    {
        HINSTANCE hDLL; 
        hDLL=LoadLibrary("TestDLL.dll");//加载动态链接库MyDll.dll文件；
        if(hDLL == NULL)  
        {  
            MessageBox("无法载入dll\n");  
            FreeLibrary(hDLL);  
        }

        dllDraw DrawNew;
        DrawNew=(dllDraw)GetProcAddress(hDLL,"GetPointIO");

        if(DrawNew == NULL)  
        {  
            MessageBox("第二步无法载入dll\n");  
            FreeLibrary(hDLL);   
        } 

        CPoint *m_point = new CPoint[4];
        m_point = DrawNew();

        CPoint point[4];
        for(int i=0;i<4;i++)
        {
            point[i]=m_point[i];
        }

        pDC->MoveTo(m_point[0]);
        pDC->LineTo(m_point[1]);
        pDC->LineTo(m_point[2]);
        pDC->LineTo(m_point[3]);
        pDC->LineTo(m_point[0]);

        FreeLibrary(hDLL);
        m_nControl=0;
        delete []m_point;
        m_point = NULL;
    }

最后得到结果如图：

以上就是全部内容了。

Python 调用动态链接库

• linux操作系统中动态链接库为so文件。
• python调用so文件使用动态方式加载，python中使用ctypes库
• ctypes是Python调用c的动态链接库的一个内置模块。

环境说明

• 操作系统:linux
• python: python3

构建动态链接库

• 项目结构

├── CMakeLists.txt  	# cmake构建配置文件
├── hello.cc			# 动态链接库源文件
└── hello.h			# 动态链接库头文件

• CMakeLists.txt

cmake_minimum_required(VERSION 3.1)		# 设置cmake最小版本
project(hello)					# 设置项目名称
set(src_h hello.h)				# 设置头文件
set(src_c hello.c)				# 设置源文件
add_library( hello SHARED ${src_h} ${src_c})	# 生成libhello.so库文件。

• hello.h

#ifdef __cplusplus
extern "C"{
#endif

#ifndef _HELLO_H_
#define _HELLO_H_

// -------------- so基础调用 -------------
void say_hello();				// 基础调用，无参数调用
void say_hello2(int iNum);			// 传递int类型参数
void say_hello3(const char *str);		// 传递char * 字符串
int  say_hello4(int iNum1,int Num2);		// 传递两个参数，并且带返回值。

// -------------- so结构体调用 -------------
struct POINT{
	int x;
	int y;
};
struct POINT get_mouse_position();		// 返回结构体
struct POINT *get_position();			// 返回结构体指针
void release_point(struct POINT * ptrData);	// 将结构指针作为参数

// -------------- so 回调函数 -------------
typedef void (callback)();
typedef int (callback2)(int);
void send_message(int a, callback funcPtr);	// 无参数的回调函数
int send_message2(int a, callback2 funcPtr);	// 带参数，带返回值的回调函数

#ifdef __cplusplus
}
#endif
#endif

• hello.c

#include <stdio.h>
#include <stdlib.h>
#include "hello.h"
void say_hello(){
    printf("hello\r\n");
}

void say_hello2(int iNum){
    printf("hello2 num:%d\r\n",iNum);
}

void say_hello3(const char *str){
    printf("hello3 str:%s\r\n",str);
}

int  say_hello4(int iNum1,int iNum2){
    int res = iNum1 + iNum2;
    printf("hello4 res:%d\r\n",res);
    return res;
}
struct POINT get_mouse_position(){
   struct POINT temp;
    temp.x = 12;
    temp.y = 13;
    return temp;
}
struct POINT *get_position(){
   struct  POINT *temp =NULL;
    temp = (struct POINT *)malloc(sizeof(struct POINT));
    temp->x = 10;
    temp->y = 20;
    return temp;
}

void release_point(struct POINT * ptrData){
    if(NULL != ptrData){
        free(ptrData);
        ptrData = NULL;   
    }
}
void send_message(int a, callback  funcPtr){
    printf("send_message a:%d\r\n",a);
    if(funcPtr != NULL)
    funcPtr();
}


int send_message2(int a, callback2 funcPtr){
    printf("send_message2 a:%d\r\n",a);
    if(funcPtr != NULL){
        int res= funcPtr(6);
        printf("回调函数的执行结果为：%d\r\n",res);
    }
    return 5;
}

• 构建步骤，如果生成libhello.so文件那么就构建成功了

mkdir build
cd build
cmake ..
make

python动态链接库基础调用

将so文件拷贝到py文件的同级目录
运行命令：

python3 main.py

目录结构如下：

├── libhello.so
└── main.py

main.py

import ctypes
from ctypes import *
solib =  ctypes.CDLL('./libhello.so')

func_say_hello = solib.say_hello
func_say_hello()
print("func_say_hello 执行完毕!")
print("============================")

func_say_hello2 = solib.say_hello2
func_say_hello2(2)
print("func_say_hello2 执行完毕!")
print("============================")

func_say_hello3 = solib.say_hello3
str = "I love you"
func_say_hello3(str.encode("UTF-8"))
print("func_say_hello3 执行完毕!")
print("============================")

func_say_hello4 = solib.say_hello4
res = func_say_hello4(5,6)
print("func_say_hello3 执行完毕!结果为：",res)
print("============================")

执行结果如下：

hello
func_say_hello 执行完毕!
============================
hello2 2
func_say_hello2 执行完毕!
============================
hello3 I love you
func_say_hello3 执行完毕!
============================
hello4 11
func_say_hello3 执行完毕!结果为： 11
============================

python动态链接库结构体调用

main.py

import ctypes
from ctypes import *

class PyPointStruct(Structure):
    _fields_ = [
        ("x", c_int),
        ("y", c_int),
    ]

solib =  ctypes.CDLL('./libhello.so')

func_get_mouse_position = solib.get_mouse_position
func_get_mouse_position.restype = PyPointStruct # 设置函数返回结果的类型为结构体
resp = func_get_mouse_position()
print("res2:",resp.x)
print("res2:",resp.y)
print("============================")

func_get_position = solib.get_position
func_get_position.restype = POINTER(PyPointStruct) # 设置函数返回结果的类型为结构体指针
resb = func_get_position()
print("res3:",resb.contents.x)
print("res3:",resb.contents.y)
print("============================")

执行结果如下：

res2: 12
res2: 13
============================
res3: 10
res3: 20
============================

python动态链接库回调函数

main.py

import ctypes
from ctypes import *

solib =  ctypes.CDLL('./libhello.so') 	# 加载动态链接库

def cb_sayhello():						# 无参数的回调函数
    print("python hello")

def cb_sayhello2(res):					# 带参数有返回值的回调函数。
    print("python hello2,res:",res)
    return 1024


solib =  ctypes.CDLL('./libhello.so')   

func_send_message = solib.send_message
# CFUNCTYPE定义方法的签名，第一参数表示方法的返回类型，后面开始编译参数的类型
funcStruct =  CFUNCTYPE(None)			
solib.send_message(10,funcStruct(cb_sayhello))
print("============================")

send_message2 = solib.send_message2
# CFUNCTYPE定义方法的签名，第一参数表示方法的返回值，后面开始编译参数的类型
funcStruct2 =  CFUNCTYPE(c_int,c_int)
send_message2(10,funcStruct2(cb_sayhello2))
print("============================")

执行结果：

send_message a:10
python hello
============================
send_message2 a:10
python hello2,res: 6
回调函数的执行结果为：1024
============================

Note:在一个项目中，我使用python调用动态库，发现奔溃的现象。
具体问题如下，
我将python中的回调函数传递给so调用，但是so的程序中使用了多线程调用回调函数，由于python的回调函数时通过构造对象的方式调的send_message2(10,funcStruct2(cb_sayhello2)) 其中,funcStruct2(cb_sayhello2)是一个对象，因此在这个函数执行完成后会释放这个对象，在so的程序中多线程函数执行回调函数对象就已经被释放了 ，因此照成回调函数调用崩溃的情况。

代码下载地址
https://download.csdn.net/download/arv002/33253778

1. 准备工作

1. 用vc做一个静态链接库

建立一个静态链接库

添加头文件 SampleLib.h

//SampleLib.h
/** \brief n1+n2
 * \param n1 第一个加数
 * \param n2 第二个加数
 * \return 返回整型结果
 */
int addition(int n1, int n2);

添加源文件 SampleLib.cpp

#include "stdafx.h"
#include "SampleLib.h"
int addition(int n1, int n2)
{
	return (n1 + n2);
}

这时会在工程目录的Debug文件夹中找到 SampleLib.lib 文件

2. 用vc调用静态链接库

新建一个控制台应用程序,来调用上面写的静态库, 注意: 调用静态库要把上面的 SampleLib.lib放在当恰工程目录下,我在工程目录下新建了一个libs文件夹,来专门放函数库文件. 同时, 还要把上面生成的头文件SampleLib.h拷贝过来, 并添加到工程当中. 如图

实现代码如下:

#include "stdafx.h"
#include "SampleLib.h"    //调用函数库的头文件
#pragma comment (lib,"libs/SampleLib.lib")    //调用函数库,第二个是.lib文件放置的相对路径
int main()
{
	int sum;
	sum = addition(3,2);
	printf("%d\n", sum);
	return 0;
}

输出结果是 5

3. 生成一个动态链接库

由于,生成dll文件时要对导出函数声明,而调用dll文件时又要重新对调用的函数再声明一次,因此,用条件编译的方式,将其一次性写出来,这样用的时候就不用重新定义(此处参考了<<visual c++ 宝典>>):
dll的头文件 ShowDlg.h

//声明导出函数
#include "StdAfx.h"
#ifndef SHOWDLG_H
#define SHOWDLG_H
extern"C"    //此处代表按c风格编译,避免c++独特的编译方式,是的函数名发生改变
{
#define DLLMODLE_FUNCTIONTYPE __declspec(dllexport)    //导出函数,声明dll的导出函数时,编译此处
//声明导出函数
DLLMODLE_FUNCTIONTYPE int mul(int a, int b);    //声明导出函数,两数相乘
DLLMODLE_FUNCTIONTYPE int div(int a, int b);    //导出函数,a/b
}
#endif

定义文件 ShowDlg.cpp

#include "StdAfx.h"
#include "ShowDlg.h"
int mul(int a, int b)
{
	return a*b;
}
int div(int a, int b)
{
	return a/b;
}

编译成功后会在Debug文件夹中生成一个SampleDll.dll文件和SampleDll.lib

2. 用vc调用动态链接库

还是用第二部分设计的函数来调用dll文件,把ShowDlg.h拷贝到工程目录下,把SampleDll.dll文件和SampleDll.lib拷贝到libs文件夹中
头文件

#include "stdafx.h"
#include "SampleLib.h"    //调用函数库的头文件
#pragma comment (lib,"libs/SampleLib.lib")    //调用函数库,第二个是.lib文件放置的相对路径
#include "ShowDlg.h"
#pragma comment (lib,"libs/SampleDll.lib")
extern"C"
{
__declspec(dllimport) int mul(int a, int b);    //声明导出函数,两数相乘
__declspec(dllimport) int div(int a, int b);    //导出函数,a/b
}
int main()
{
	int sum;
	sum = addition(3,2);
	printf("%d\n", sum);
	sum = mul(3,4);
	printf("%d\n", sum);
	return 0;
}

这样还不行,因为默认查找dll文件的路径是 C:\Windows\System32,要在projct->setting中进行如下设置

运行结果

3. 用C#调用C++动态链接库

编写C#的demo,在visual stodio2017中新建一个C#语言的控制台应用程序

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ccproject1
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("hello world");
            Console.ReadLine();
        }
    }
}

这是一个输出 hello world 的简单控制台应用程序,它的工程启动目录是: 工程名\bin\Debug 这个路径待会要用到
现在添加引入DLL文件的语句:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
//加入下面的引用,DllImport在该命名空间内
using System.Runtime.InteropServices;
namespace ccproject1
{
    class Program
    {
        [DllImport("../SampleDll.dll")]    //引入dll文件,注意:引号内的是文件路径
        									 //"SampleDll.dll"   为默认路径C:\Windows\System32
        									 //"/SampleDll.dll"  这是当前工程的启动目录,也就是前文提到的工程名\bin\Debug 
        									 //"../SampleDll.dll" ..代表上一级目录,也就是dll文件放在了Debug文件夹下
        									 //路径可以用"\",不过由于"\"的特殊性,应用两个如:"..\\SampleDll.dll"
        public extern static int mul(int a1, int b1);    //声明要调用的函数,该函数返回a1*a2的值
        static void Main(string[] args)
        {        
            int c = 0;
            c = mul(3, 4);
            Console.WriteLine(c);
            Console.ReadLine();
        }
    }
}

输出结果如下