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部分

+ U- r( ?5 ^4 U( |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[])

举个栗子：

• 
  
  #include "mex.h" // 使用MEX文件必须包含的头文件
  
  % f5 q4 l: u" Z  }
• 
  
  9 V/ w7 O: T0 x6 @5 B" i// 执行具体工作的C函数
  
  
• 
  
  * n) T! ~* B/ v6 Z) i6 Q: Vdouble add(double x, double y)
  7 h0 {8 v% w& Z2 c; q2 L- v' y
  
• 
  
  {
  ( ~: p4 R8 P, f9 c3 F8 i; |
  4 K0 Y# l9 E3 S2 Z% f' l' H
• 
  
  6 l1 Z) J: Z2 }3 D8 f    return x + y;
  9 I" N5 U1 Y" |: \' z7 H
  
• 
  7 y! C! l, V7 d$ q4 y# Z# _
  }
  & n' L: t3 K& A) H
  
• 
  
  // MEX文件接口函数
  
  - b+ ]+ x5 f: p  |* i# t9 z
• 
  . c+ P' T" f+ n& V+ V
  4 y6 b1 w" @; R3 H* wvoid mexFunction(int nlhs,mxArray *plhs[], int nrhs,const mxArray *prhs[])
  
  7 G7 E* X0 l6 P$ j+ |. i
• 
    `1 K5 J7 i3 p9 A
  9 u7 f7 L1 |2 _, |+ T" U1 }- h3 p{
  * ?" ^8 F" ?3 o! y- b" \
  
• 
  
      double *z;
  
  
• 
  
      double x, y;
  - M1 N/ z5 G! t, r! N4 _
  
• 
  
  & t; O! t* y3 W    plhs[0] = mxCreateDoubleMatrix(1, 1, mxREAL);
  
  0 g3 ]; z. k, B& _/ q4 _
• 
  
  . j1 s& p. C! V8 ]    z = mxGetPr(plhs[0]);
  
  
• 
  
  ! y2 y- F+ K' f# ]8 m7 }1 f. m    x = *(mxGetPr(prhs[0]));
  : \* k: m0 Z" H) n3 @3 p
  ! X& x/ f7 ?# a* k- ~
• 
  
      y = *(mxGetPr(prhs[1]));
  
  / ?5 b3 D: d$ U' E( M! I
• 
  
      *z = add(x, y);
  ( s; {( Y" t2 Q( d) Y
  
• 
  
  * \0 y& [2 ]" A1 z5 C  ~$ I" q}
  
  
  . V" U* x2 D# R: Z/ W: P- X

也可以写成：

• 
  
  8 k( |% {* X! j! B, v% t& p#include "mex.h" // 使用MEX文件必须包含的头文件
  
  , f% E  J5 ^( r2 ?: \. _
• 
  
  // MEX文件接口函数
  
  * k) z! \' O& v$ b+ p+ U0 C. Z+ \
• 
  5 |6 U- d( a& e. g( W- |4 Q
  void mexFunction(int nlhs,mxArray *plhs[], int nrhs,const mxArray *prhs[])
    P; @' g  l3 t8 N$ Q/ f5 q
  ' W$ j5 w$ F, W
• 
  % o4 c" F4 i8 q5 e% [: W' W
  ' O2 m# u/ r/ r" J" g7 A: S{
  
  4 w: B- f! [+ n& c" o
• 
  
      double *z;
  
  
• 
  
      double x, y;
  ! a  n, G! r& n
  
• 
  : J5 e% i$ `3 X6 D9 W! l9 U
  . b1 [% |8 }7 j! Q0 C4 r    plhs[0] = mxCreateDoubleMatrix(1, 1, mxREAL);
  9 S, u- X$ `' q7 E
  
• 
  
  ' |8 l- w" X# U, ]& S    z = mxGetPr(plhs[0]);
  ! j* z9 }" t$ J" A7 Y6 G% Q. S2 |" l
  ; ^# ~7 k; c$ h
• 
  
  ) k8 t& |/ d$ k  ~    x = *(mxGetPr(prhs[0]));
  # ?  T. O# J" P1 Z5 B; b
  
• 
  ) Z9 _" j: H5 o
      y = *(mxGetPr(prhs[1]));
  0 d# x- N" I' ?
    |9 ]3 T: y3 w% f
• 
  
      *z=x+y;
  
  ' w$ c% f# l- ~+ v. u) G: ]
• 
  , a8 M, F" @, K/ i+ x3 Y
  9 @" v6 [% Q% R6 }; P7 C& M- c& q3 P}
  2 e" i. F1 g/ y& L3 X  m% \/ S6 Q
  
  

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

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

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

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

再调用c语言函数

分工明确。

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

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

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

参数

意义

英文全称

类型

, T* R9 p# P: s/ bnlhs左边输出参数的数目number of left-hand side整型（int）
( _) N; r) b( y+ c  y) F  ]; z6 hplhs指向输出参数的指针pointer of left-hand side指针数组
nrhs右边输入参数的数目number of right-hand side整型（int）
prhs指向输入参数的指针pointer of right-hand side指针数组

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

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

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

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

• 
  ' J  W2 h) ~9 p: t6 _4 V" R
  / U/ w+ o. S' w#include "mex.h" // 使用MEX文件必须包含的头文件
  / |6 q0 C3 N# [8 h2 o. O
  
• 
  
  // MEX文件接口函数
  
  
• 
  : [4 q, p1 ~+ L
  void mexFunction(int nlhs,mxArray *plhs[], int nrhs,const mxArray *prhs[])
  
  5 i% M( ^. ^4 ^: {2 x/ k( L  B
• 
  / I) W, |) Q9 _5 a
  - B! }2 M$ J! _  P{
  
  ) J0 T  S. J) V2 u. c
• 
  
      double *z;
  
  / f; U, v1 S6 ~( A# T0 J
• 
  
      double x, y;
  
  
• 
  
  5 T$ ~& _! C; l    plhs[0] = mxCreateDoubleMatrix(1, 1, mxREAL);
  9 P  {& N! T7 ]/ W$ Y0 P9 k8 C6 H  F
  
• 
  
  + h! \, @% ~& r2 q$ ^4 b- t7 j% A    z = mxGetPr(plhs[0]);
  ( p& I. N, v5 O# b( O5 e  p" ]
  3 t! w* C. e1 h8 I
• 
  
  6 r" i7 t. ?+ [* Z; R% W    x = *(mxGetPr(prhs[0]));
  ) p$ v5 G) D3 d- l4 V+ C( q% \
  & a4 \! C& N" W" K1 Y( t& M
• 
  ) |2 g+ h# p1 D
  ) o# d2 u' N9 {9 P    y = *(mxGetPr(prhs[1]));
  9 R/ _, `) H& I. M; q
  " T; n6 [  y8 g" o  k' \- r
• 
  ; l' H0 Y6 M' s- L* I- D
  7 |1 g3 E7 P* s3 X5 k- I8 b    *z=x+y;
  
  7 F5 w7 R8 {7 O: |' Q
• 
  : J/ h5 W: n7 L8 H& A4 x, ]; o
  }
  * g3 `; {. i' c
    ?2 Y% J% @' |0 p8 S- U* G# T
  ! k8 A, y* ~9 n% v

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

plhs和prhs其实都是指针数组

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

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

• 
  
  x = *(mxGetPr(prhs[0]));
  0 z3 v% m1 O) ^6 f  r* J  L
  
• 
  
  - L8 d1 w7 L( p# o/ C6 ay = *(mxGetPr(prhs[1]));
  2 @, r6 d6 F) C& y) R
  * O; \- ?/ i6 q
  

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

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

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

• 
  
  #include "mex.h" // 使用MEX文件必须包含的头文件
  ! k* I) L; H$ b8 g- ^/ G! c$ e  y0 ?
  5 i& c! T* S3 p" x: `6 h! y# V/ f1 ~
• 
  
  7 B$ Z% c( a- Q1 t1 b6 k9 G! @// MEX文件接口函数
  + ?8 G9 L" ^$ P' C  v" f& r
  
• 
  ( f6 V6 V/ V. J2 T* E
  : ]" i. n( `' f9 r: p" T. rvoid mexFunction(int nlhs,mxArray *plhs[], int nrhs,const mxArray *prhs[])
  6 h4 u' M/ B8 T" u
  8 T0 D0 P, z0 S0 h* [( v6 t8 h
• 
  
  {
  
  
• 
  2 ~$ j5 d3 w2 D5 D
      double *z;
  
  3 @( d1 Q  k: U# p0 @3 T" |
• 
  & W% V" k3 a' o
      double x, y;
  % @8 l! d* _- `) s
  
• 
  
  2 D4 }( c$ ^. @    plhs[0] = mxCreateDoubleMatrix(1, 1, mxREAL);
  : q) t; r7 w: _8 N
  3 b; |, _+ r' b4 E
• 
  ; ^- A- m) C( ^  U% m
  # o8 q  k4 @7 K  p7 F/ e    z = mxGetPr(plhs[0]);
  
  0 R- q( i( l6 [0 P9 o0 ^
• 
  
  - O0 ]2 r6 l2 z" a5 R! x  M0 n    x = mxGetScalar(prhs[0]));
  
  
• 
  
      y = mxGetScalar(prhs[1]));
  % K8 x& ]. m; ]3 s! q
  : W+ C( K% |8 f7 j& ^' A$ u$ P" p* t0 e
• 
  
      *z=x+y;
  , W) e; [+ T2 c8 @" k
  ) r2 N! E8 E* A% r, Q, P2 F
• 
  
  }
    v; Q# e: W& U6 D* l$ [
  
  

(注意：输出参数因为需要通过指针传出，因此这里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]

举个栗子：

• 
  - H) a2 B5 m1 V8 k# j/ R
  - t: p- [$ E2 ~# U5 g/ N#include "mex.h"
  
  / R. }/ [  \) `6 C6 u
• 
  
  ; I) u+ B6 T) [% i" I% K void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]){
  
  ) d9 O1 Z& I5 M+ ]" K' Z: i3 |
• 
  
  
  
  # ^& ?/ r5 @4 ]% k
• 
  
  % `" o( G; }1 ~( W/ c" c5 ndouble *data;
  
  
• 
  
  int M,N;
  / U2 W% p5 R. J
  / [) J* j2 ]4 y7 u& a6 ^
• 
  
  int i,j;
  # X# p9 x* g# L* k" \0 }
  % k9 K9 _" I7 ^/ g9 C# @
• 
  % Y" l+ B$ }6 ]; Q. k, Z  L" C
  data=mxGetPr(prhs[0]); //获得指向矩阵的指针
  & K, _, g& ?5 k: M
  
• 
  / D! f6 J; S/ a9 W# E" C  n! U7 z
  M=mxGetM(prhs[0]); //获得矩阵的行数
  . q7 [2 n' ^  j' O9 ?
  
• 
  $ w; s$ c1 \: g6 c
  8 ^! W9 D3 g. a% i3 o1 ~N=mxGetN(prhs[0]); //获得矩阵的列数
  3 X! }3 e* W- n  Q' ~
  
• 
  
  % b0 u! T0 @7 B: a# y% Yfor(i=0;i<M;i++)
  
  
• 
  
  {
  8 M- l% q& ~6 {; L9 f
  
• 
  
     for(j=0;j<N;j++)
  
  
• 
  / }4 k/ H$ u. _
  7 P  u  d1 ?% |7 T9 x    mexPrintf("%4.3f  ",data[j*M+i]);
  ) s" |, ?3 `5 U7 ~: x- ~
  
• 
  ; z3 C3 [) g" a, B6 V0 ]
  * r9 L' J5 y2 ?- f2 I   mexPrintf("\n");
  0 ^' X% E0 Y4 j1 H  }' S
  ; D$ C5 y" i9 K" t9 h1 Z8 I4 W
• 
  
  }
  
  
• 
  - W- H* w: B3 ]
    c/ `7 m( S* t* C2 t }
  % l8 F0 ]: x* U0 j5 ~
  9 N0 S5 ]2 l. z3 f$ l: P; f
  4 }2 T, j7 O, W: y% O

假如是一个形如[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

• 
  ) j6 E+ E# f( \. }  q+ ~8 X
  8 J: Z8 Q9 ]0 E: v3 x' m! k
  
  
• 
  : U  z( X9 X+ s/ e( Z) d7 C
  % c5 v1 F5 H; L/ J& C/ Q7 x  J# A    double *z;
  8 k& _" m, z+ O; F- k; }# @5 F
  ' f( z. x6 l; s
• 
  
  4 }- P; V% ^% u% T4 Z6 t$ s3 Y7 l    plhs[0] = mxCreateDoubleMatrix(1, 1, mxREAL);
  
  
• 
  3 k/ C$ t; C' G$ y' K& C
  1 Y9 \- }. V7 f- ]; p    z = mxGetPr(plhs[0]);
  0 T3 e3 @+ R" Z" r( y; k2 L6 G3 C
  ; I1 u; w+ u5 T+ k* s
• 
  
      x = *(mxGetPr(prhs[0]));
  : r7 s7 k+ I& O9 d7 y1 c
  
• 
  
      y = *(mxGetPr(prhs[1]));
  - N  }9 D5 v, j8 U& Y" r: [3 _: D
  
• 
  . O$ P, A$ c# i, J, [( D) h% r  L
      *z=x+y;
  
  4 @' `. g- A$ R5 N' p1 x: J
  

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

youOK

matlab与c语言混合编程