matlab与c语言混合编程

mutougeda

前言：

众所周知对于循环这种运算，matlab的运算速度是不快的

想起来个冷笑话，黑客帝国里的主角呢奥之所以能快过子弹，因为Matrix是matlab写成的hhhh

因此将循环部分用C语言写，然后编译成matlab可以调用的mex文件，无疑可以加快循环运算速度，从而加快整个代码速度

之前因为合并数据需要不会数据库，强行在matlab里利用类似excel的vlookup功能，无奈太慢，只能想办法最后知道了这种方法，最近偶然在桥哥的知识星球里又提到了，也顺便复习和记录一下。

ps:今天在闲鱼上买了小车车，高兴！

---

1.环境配置

我的是matlab2019a，win10-64bit，c语言编译器我选的是TDM-GCC（gcc/g++），安装起来很简单，推荐matlab2015及以后的选择这种，详细安装过程可以见文末链接1中的For Matlab 2015部分

2.如何编写可以被编译成matlab可执行文件的c语言代码

我是在matlab中文论坛（地址见reference第2条）里找到如何编写的，不过他写的有点乱，我来消化后写一下自己的理解

mex接口函数跟一般的C语言文件主要是两点区别，

第一是必须引入头文件mex.h

#include "mex.h"

第二是多了一个叫mexFunction的函数

void mexFunction(int nlhs,mxArray *plhs[], int nrhs,const mxArray *prhs[])

举个栗子：

• 
  
  + J0 J; J. C& |#include "mex.h" // 使用MEX文件必须包含的头文件
  
  + D/ s/ I( B( N, A
• 
  
  // 执行具体工作的C函数
  2 S3 F# M9 R1 H8 V
  & X* y( ]/ u& A# ^6 b9 |
• 
  
    M( q9 f4 t. l1 mdouble add(double x, double y)
  
  4 w; I9 ?$ S4 z) @- Z  j3 \
• 
  & j& ]- `. l  K$ \2 U/ T
  4 B/ i' d- e. s1 K1 q: A{
  
  ; y3 I3 ]3 U+ Y0 T
• 
  
      return x + y;
  
  
• 
  
  }
  : v, @4 j, m. N3 H. I: b0 ^& V5 T
  8 G  T9 p& h; _! Z2 `2 @* k
• 
  * [9 U0 }7 f) W4 z: t+ K! @
  // MEX文件接口函数
  3 M# K4 a& i' Q% h9 g& M
  8 q4 D( b4 y$ W6 P6 Q
• 
  . J+ T: N, D* ]" p( |
  void mexFunction(int nlhs,mxArray *plhs[], int nrhs,const mxArray *prhs[])
  1 g( [  ^: {% A6 ]
  ) w/ t6 j% L# J
• 
  2 i% j( @( Z8 y
  2 E4 U+ B9 P) y" Z* d! q  Y{
  
  1 u) t1 u) a  ], P0 X  q
• 
  , d( }% w( O  Q
      double *z;
  
  
• 
  7 G4 ]+ X" _" @- T
      double x, y;
  
  ! N, T0 H: W* Y
• 
  2 @1 F" Z+ S; ^
      plhs[0] = mxCreateDoubleMatrix(1, 1, mxREAL);
  ; m5 @/ ^$ |$ W
  - @7 K" p5 T, ?
• 
  
      z = mxGetPr(plhs[0]);
  
  
• 
  
  & U( K7 A& m. a9 b8 k, L& W    x = *(mxGetPr(prhs[0]));
  
  
• 
  - m/ _* c8 F4 }+ ^# d( M8 @- R  K
      y = *(mxGetPr(prhs[1]));
  
  9 W7 ?) W" N7 Y  `$ V, w: x( W
• 
  
      *z = add(x, y);
  
  
• 
  
  }
  9 Q- B: a7 T5 A9 ^. U5 [( [
  - B2 [) I! E' h, |& \
  

也可以写成：

• 
  + @1 _" h+ `( s* W! k0 p. T6 x8 M
  #include "mex.h" // 使用MEX文件必须包含的头文件
  
  1 n% ~( p7 J, k5 T& Q/ j0 X  D
• 
  " l" r) b* R4 }% C8 ]3 Y
  ) W9 t" n- }5 q' y7 P! G- H8 j5 G/ ^// MEX文件接口函数
  
  
• 
  
  void mexFunction(int nlhs,mxArray *plhs[], int nrhs,const mxArray *prhs[])
  
  
• 
  
  9 ~4 Q# Z* |+ h: x+ p* X{
  " S) [5 b& f1 D0 z2 o) H- d
  
• 
  
      double *z;
  & K% W1 E, Z3 e/ f" b# K+ {
  : b. t7 i" W0 K
• 
  
  ! u, p: b$ T6 x6 q/ Y$ D5 p( @    double x, y;
  
  
• 
  
      plhs[0] = mxCreateDoubleMatrix(1, 1, mxREAL);
  
  
• 
  ) {! J6 I& t$ l) g; L( L6 E( z8 c
  5 H/ p2 W+ l) S0 s7 y    z = mxGetPr(plhs[0]);
  5 u) d% l( h3 K! g9 D% m9 y# F
  
• 
  
  2 k7 y" S. p  j% i" @& P- z    x = *(mxGetPr(prhs[0]));
  ; g) W. P4 l$ U/ ]" ~' Z' ~* c4 U6 x
  # D& t: _- J; ~7 S! o8 p
• 
  + }! R) y7 i) l  V7 D
      y = *(mxGetPr(prhs[1]));
  
  
• 
  ; d1 N! r4 F5 @( L( B1 T0 z; [
      *z=x+y;
  
  ! V" E) p0 k! l# z
• 
  5 z% m  Z9 U! g: ^( A4 _
  " U3 e- n8 l4 O}
  ) n9 e1 |/ y7 e0 n7 J5 h
  7 C4 S* r6 ]: B6 u4 ^" {5 ?7 A
  0 o7 Q' }/ D0 C0 I

也就是说执行具体功能可以通过编写一个独立的c语言函数在接口函数里调用，也可以直接写在mexFunction接口函数里

我个人推荐将具体功能独立出来，这样一来：

c语言函数负责执行具体功能

mexFunction接口函数负责数据的输入输出（将matlab数据输入c语言环境，运算后再输出回matlab）形式组织

再调用c语言函数

分工明确。

于是关键问题就是如何编写mexFunction接口函数了

void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])

下面解释一下mexFunction各个参数的含义（这里看到是void,即无返回值，因为传值是通过指针数组plhs[]传出的）

参数

意义

英文全称

类型

; f5 @' n9 ^. K" fnlhs左边输出参数的数目number of left-hand side整型（int）
. [, v8 q" Z9 r5 j4 D' N5 splhs指向输出参数的指针pointer of left-hand side指针数组
8 w8 n% k7 ?% [2 J9 p: \4 Snrhs右边输入参数的数目number of right-hand side整型（int）
7 K+ ?, d' x" i+ T3 K) hprhs指向输入参数的指针pointer of right-hand side指针数组

第一个参数nlhs是输出参数的数目,第二个参数plhs是指向输出参数的指针

第三个参数nrhs是输入参数的数目，第四个参数prhs是指向输入参数的指针

其中plhs和prhs类型都是指向mxArray类型数据的指针，prhs这里还加了个const,这里的const跟之前c语言中是一样的，代表不改变，因为prhs是指向输入参数的指针，mxArray这个数据类型是在头文件mex.h中定义的，in fact ,在matlab中大多数数据都是以这种类型存在。

还是拿之前的栗子来解释：

• 
  
  / W8 a/ S7 g+ F5 k#include "mex.h" // 使用MEX文件必须包含的头文件
  5 G) t0 S; ^) q! N5 z
  % w- U, a2 [: N# r
• 
  
  // MEX文件接口函数
  
  0 T8 K6 E; Y+ w) H
• 
  
  . U; O; ]( S& ], s3 G2 Lvoid mexFunction(int nlhs,mxArray *plhs[], int nrhs,const mxArray *prhs[])
  9 x) M9 v3 X. u. s
  
• 
  
  ' M" l/ V# a  T/ q{
  
  , X6 G4 n8 ?: a- b3 Q
• 
  
      double *z;
  
  * \6 h# u7 B7 A! e* H  m% I
• 
  - n2 D/ ?; v+ p2 r) k
      double x, y;
  
  / V5 n% X& ~; P# C' i
• 
  1 {+ i" v1 d6 I( I. }- M: C$ u0 k
  0 Z' Z. }4 y8 [$ i( d0 b9 _    plhs[0] = mxCreateDoubleMatrix(1, 1, mxREAL);
  5 ^+ p. v, Z9 V7 G- V9 N( a
  
• 
  : w- W: v% q3 \& R) B, _! Q
      z = mxGetPr(plhs[0]);
  
  ' ]! ?8 u" J. Z% y0 t3 R
• 
  
  0 w( j$ z1 z% K& l: L  X+ [' H    x = *(mxGetPr(prhs[0]));
  
  " }% W6 t0 t& ^8 |) @- M
• 
  
  7 S/ P; u5 }- X( P    y = *(mxGetPr(prhs[1]));
  9 A1 Y7 y' X' U2 @" {2 y; x
  1 c3 G2 ?1 j/ l! S  C5 O
• 
  2 N) T% s, F2 w7 l6 o( Z7 i7 h* v
  % m; J0 ], @8 R8 z3 V: A0 k    *z=x+y;
  
  
• 
  * A$ o' o- U0 P) A1 n5 i  Y- l( g
  }
  9 L6 ]% v. L0 {+ N+ z6 B+ ?4 K8 t
  
  $ y; u! w1 \! c* J2 j, ^$ X( j9 l

在这个栗子中，输入参数是x,y,输入参数是z(虽然没有返回）

plhs和prhs其实都是指针数组

prhs[0]代表指向第一个输入数据的指针，mxGetPr代表获得这个指针，后面再加个*就是c语言里面再正常不过的按指针取内容了

所以就这样x,y通过下面这两句传入到了mexFunction中

• 
  
  x = *(mxGetPr(prhs[0]));
  & S/ S3 n# x4 A6 \4 T
  
• 
  2 S) l/ g- N- V6 l' ?6 R
  ; `) @& V; E! T' Q' m% S! Zy = *(mxGetPr(prhs[1]));
  
  
  

mxGetPr函数的功能是从指向mxArray类型数据的指针prhs[0]、prhs[1]中获得了指向double类型的指针

另一个函数是mxGetScalar,Scalar即标量，功能是把通过prhs传递进来的mxArray类型数据的指针所指向的数据（标量）赋给c程序里的变量。前面的mxGetPr是传递矢量的，否则矩阵或者向量就没有办法传进来

这里由于传入的每个参数是单个值，于是也可以用mxGetScalar改写：

• 
    A9 }, K; m$ Z9 C' @1 I% h6 T3 R
  #include "mex.h" // 使用MEX文件必须包含的头文件
  6 P5 L' Y0 x$ {. @' \* I) q6 A
  
• 
  
  // MEX文件接口函数
  " Q. k& D- P& y. G9 ?
  
• 
  
  % M0 [5 c% ^& M: Q+ F0 i1 Qvoid mexFunction(int nlhs,mxArray *plhs[], int nrhs,const mxArray *prhs[])
  
  
• 
  , f8 G2 G3 {. I- [7 K3 v
  {
  - e8 s5 u: g1 K1 q, @
  
• 
  
      double *z;
  ; |# j- p+ @& p! Q
  
• 
  6 e- K0 O  Q# f8 c( `- N5 O- L
  8 }1 @: ]. i& i: B) Y    double x, y;
  ' H3 t1 M- x7 y9 Y% U/ a
  : [+ J! q4 c, y' S' d  v/ Z
• 
  ; X) I& @8 ~. h: M2 w& e
      plhs[0] = mxCreateDoubleMatrix(1, 1, mxREAL);
  
  
• 
  
      z = mxGetPr(plhs[0]);
  
  
• 
  6 _( Y# t0 k$ V- f1 c
  8 }# ^% }, Z& t8 g/ d    x = mxGetScalar(prhs[0]));
  ' }' L8 e- f; @" K* f2 L! Z
  / p% e& t; r( S) N: p) M  L
• 
  
      y = mxGetScalar(prhs[1]));
  
    f+ \- @1 M3 N2 K& ~
• 
  
  8 _3 I7 _) Q! C4 K; t, |    *z=x+y;
  
  
• 
  
  % t# L6 J, m% d2 Z/ r( d}
  
  
  2 ~$ P; a4 _4 s" {" D2 k8 @

(注意：输出参数因为需要通过指针传出，因此这里z必须用mxGetPr这个函数来从mxArray指针获取double指针）

但是这样还是有个问题：如果输入的不是单个的数据，是向量或者矩阵，即使我们通过mxGetPr获得了矩阵或者向量的指针，但是我们假如不知道矩阵的shape，还是不好取值或者计算，所以这里又有两个函数mxGetM和mxGetN可以通过传入参数指针获得传入参数（矩阵）的行和列数。

需要注意的是:

在matlab中矩阵的第一行和第一列的序号是从1开始的，而在c语言中是从0开始的，而且在c语言中的一维数组存储矩阵的数据时，是一列列从上到下，从左到右来存储的，也即

matlab中一个m*n的矩阵M(i,j)对应于c语言中一维数组N中的N[j*m+i]

举个栗子：

• 
  
  #include "mex.h"
  ! _) H; d. U' T' m" z
  1 }9 d; X. L% v' K' t9 w
• 
  
  void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]){
  0 A* S& r! W$ J' A1 B& z4 U9 }
  ) o3 B- L* X7 P( ?& @# Y0 E. a
• 
  $ C6 T, h/ @5 d, n0 O
  
  " M1 a( ^8 b; k: m; ~. C
  7 H) A9 E7 X1 `
• 
  
  # Y1 W7 y7 t0 {: [double *data;
  ! w2 U) `/ n0 J# j7 C& z3 q- z" ]
  
• 
  
  int M,N;
  
  $ D. [% ?8 J6 e3 ~& U8 `5 v
• 
  & Q. ^0 d$ N; X# ]! i
  . U( w4 S1 c$ M4 z1 ]7 Xint i,j;
  
  
• 
  
  data=mxGetPr(prhs[0]); //获得指向矩阵的指针
  6 y+ k- T% N) z5 x4 t4 d  J$ G
  ) s; N/ @: {- X: n  s( D" P
• 
  ( h& H! `& c' v$ A( f
  M=mxGetM(prhs[0]); //获得矩阵的行数
  8 ]! ~1 `: F( y  h1 O2 p5 t' l
  2 \9 W2 y5 o. {
• 
  + v5 [% F6 X3 A4 d( v; d
  . E$ ?* y$ u; S$ y+ u8 ~N=mxGetN(prhs[0]); //获得矩阵的列数
  # o) ~. M' t! v  c3 p: t- G2 U
  
• 
  
  for(i=0;i<M;i++)
  ' E1 ]6 ^& P0 J. |
  7 q  b  L. y, W/ e4 v9 w% D8 S
• 
  ) [" D1 A5 x' ?' H% _
  {
  $ r+ o4 p& y- K/ i) _- g
  
• 
  
  $ B8 j6 w2 i8 v  A% O   for(j=0;j<N;j++)
  
  
• 
  
      mexPrintf("%4.3f  ",data[j*M+i]);
  % H* O' M& P) U3 Z2 ~( ]5 F( b/ M
  
• 
  
     mexPrintf("\n");
  & [8 y0 R1 o! G9 h0 C1 X
  , G2 s& m5 H) C0 h; L7 N$ _, u
• 
  8 `  C. B7 N5 N
  }
  
  
• 
  # J  R0 m$ u7 t! g+ S( C; c4 A! q
  % c* e1 y/ \" M$ Y }
  
  
  

假如是一个形如[1,2,3;4,5,6]的矩阵，则执行上述后会先后打印出1,4,2,5,3,6

以上讲的都是输入参数，由于输入数据在函数调用前就已经在matlab里申请过内存，由于mex函数与matlab共用一个地址空间，因此通过prhs传递指针即可传入输入参数。但输出参数却需要在mex函数里申请内存，才能将指针放在plhs中传递出去。由于返回指针类似必须是mxArray，所以matlab专门提供了一个函数：mxCreateDoubleMatrix来实现内存申请，函数原型为：

mxArray * mxCreateDoubleMatrix(int m,int n,mxComplexity ComplexFlag)

m,n分别是待申请矩阵的行数和列数，需要注意的是为矩阵申请内存后得到的是mxArray类型的指针，就可以放在plhs[]中传递出去了。但是对这个矩阵的处理（包括赋值）却需要在mex函数或者c语言函数中完成，这就需要通过前面的mxGetPr或者mxGetScalar。使用mxGetPr获得指向这个矩阵的double类型指针后，就可以对这个矩阵进行各种操作和运算了。

还是拿这个栗子讲，这里由于输出是一个数，于是m,n都是1，通过mxGetPr进一步获得指向double数据类型指针z

• 
  3 W6 ^# @# l- i
  
  ; O& h, ]- @# F2 n
  : a" R" B8 Y8 `& C( W3 t$ }2 V
• 
  
  . Y' A7 K0 r9 d1 m. K    double *z;
  
  4 d- _+ h# b4 E0 w
• 
  $ J' l8 A7 M/ f7 O9 F1 \  q: |
  & Q7 T3 R, Y4 A' r* y2 Q) T, `    plhs[0] = mxCreateDoubleMatrix(1, 1, mxREAL);
  1 i/ x( c+ l9 C  g% M
  
• 
  
  / y" d! Z* {- {; u# i1 \9 V    z = mxGetPr(plhs[0]);
  ! n! v( C& W$ o$ P) v
  
• 
  
  " E3 g) D4 R4 m8 a" D. m    x = *(mxGetPr(prhs[0]));
  : w3 S8 O# d: y
  : T. }0 l0 y& F# u6 w4 }
• 
  
      y = *(mxGetPr(prhs[1]));
  & P2 j5 ?+ X8 g. I2 l
  
• 
  
      *z=x+y;
  " e6 F$ m/ A+ @. ^5 G; r
  
  8 p$ Z% ?9 i3 Q7 c% s& |

当然，matlab里使用到的并不只是double类型这一种矩阵，还有字符串类型，结构类型矩阵等，并也提供了对应的处理函数。

youOK

matlab与c语言混合编程