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[])

举个栗子：

• 
  + f% g+ ]1 }8 i) |& f' D. a
  #include "mex.h" // 使用MEX文件必须包含的头文件
  . a4 H( s( E- w# A+ c" V. N9 V
  % q/ U  m: ~. s" h$ x. s. B" l4 w( I
• 
  
  // 执行具体工作的C函数
  ( v7 @" z; u$ Z# G
  
• 
  
  double add(double x, double y)
  $ r3 u( S4 j7 |& H5 c- L4 P
  
• 
  % i' M4 @6 L$ B3 u* p
  {
  3 Q1 N7 z: P; _( G' ^' @
  
• 
  - I( F2 b4 j6 b' b- ^
  ; I, A: a' u+ C    return x + y;
  
  6 \! D8 [" ^/ J8 Y7 I. ~6 e
• 
  
  }
  
  
• 
  8 r' E  R% g- q* T* ]# ?
  * m7 Y* c* F9 v. T// MEX文件接口函数
  9 K# L# W% L( s- ?, y2 Z
  " U( i8 G, c* X1 v/ w
• 
  % n. p& \) D: H
  void mexFunction(int nlhs,mxArray *plhs[], int nrhs,const mxArray *prhs[])
  * t" k8 L3 H3 e0 V; D
  
• 
  
  4 T5 g/ D3 ]+ J% H$ L2 x{
  ! w5 M: G+ Y! o8 {% I4 I
  8 p; B& k, t# ]) j% |- K
• 
  6 o& A! u% ~7 @4 {! w9 j' `; D
      double *z;
  $ G) A0 _, ]! i' H( R
  
• 
  % G0 D8 A. G) |) O/ ~5 V
      double x, y;
  
  ( N3 h; W/ x: [9 q; E- _. ^! _
• 
  
  8 e# R0 o# Z* i: I+ L8 \    plhs[0] = mxCreateDoubleMatrix(1, 1, mxREAL);
  5 }3 ^  K2 z" D4 x4 p
  
• 
  3 W2 z- R( K% V7 l4 E8 C* J4 f, Q4 P
      z = mxGetPr(plhs[0]);
  7 G! [7 Y" D0 V, M
  
• 
  
  / a7 a6 n8 w" \    x = *(mxGetPr(prhs[0]));
  
  
• 
  
  $ f, s7 y6 |* e/ n    y = *(mxGetPr(prhs[1]));
  
  ' h3 w. c% m* v+ I% G" }
• 
  
      *z = add(x, y);
  
  $ @+ h: T& U+ z% e8 t  D" }7 ^5 M
• 
  
  $ g( c. e/ G; j}
  
  9 e+ I7 h$ ~. m* f; s# `* a
  9 s/ e6 S' [% c$ I; h- _; l( v" V/ y

也可以写成：

• 
  
  7 }& G4 t9 _+ I* Z6 q/ e#include "mex.h" // 使用MEX文件必须包含的头文件
  
  , v" [4 }: D' L7 b8 |, \9 P
• 
  # e4 @! A9 D8 T; i( V$ G
  , l8 c  w+ _" o  V4 a// MEX文件接口函数
  , n. g' l/ T+ m
  
• 
  
  4 ?6 ?' H% t3 ^1 q6 @void mexFunction(int nlhs,mxArray *plhs[], int nrhs,const mxArray *prhs[])
  
  
• 
  
  1 \3 b! i3 d, d4 H; K/ |{
  
  4 u& p9 [0 f/ l; C! h9 c
• 
  
  7 V* |( L: G7 m0 s: r" m    double *z;
  
  : m) c" v1 Y" w% W8 W3 ~# `% S
• 
  $ D. Q. V7 `& u0 V2 Z
  ! n; i2 m( b* i* \    double x, y;
  
  / s2 t4 v4 q8 N' m2 @
• 
  4 C$ A/ a7 x  i% W# j1 S8 o4 Y$ W3 E
  ) c: A) A8 }9 }2 r4 R6 T5 C    plhs[0] = mxCreateDoubleMatrix(1, 1, mxREAL);
  # Y1 Q0 t* k, m/ Y( {' k; m
  
• 
  
      z = mxGetPr(plhs[0]);
  
  6 N; A; \7 r8 o! X6 H
• 
  
  $ k; _9 ?( _5 c6 \; w& C    x = *(mxGetPr(prhs[0]));
  
  
• 
  ! K; O  \3 }: P( S5 Z
      y = *(mxGetPr(prhs[1]));
  
  4 `& s5 V; R% x) G& T1 I$ w
• 
  
      *z=x+y;
  
  
• 
  
  1 n% [5 U3 ~8 f! Y1 h* W}
  6 K1 o  G9 B' y! g; O8 |) A% j
  4 u1 A/ B) O1 C: S6 }  Q- O, g. n
  

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

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

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

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

再调用c语言函数

分工明确。

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

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

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

参数

意义

英文全称

类型

nlhs左边输出参数的数目number of left-hand side整型（int）
plhs指向输出参数的指针pointer of left-hand side指针数组
nrhs右边输入参数的数目number of right-hand side整型（int）
- k- n) d% Y; A6 `# U3 \$ L- Yprhs指向输入参数的指针pointer of right-hand side指针数组

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

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

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

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

• 
    [- z  O1 I) j! N" n
  # {) j& I7 ~; l; R* t  K, D#include "mex.h" // 使用MEX文件必须包含的头文件
  
  . m* D$ T9 I" g( t
• 
  
  7 b! p( j& m3 e' B- ?// MEX文件接口函数
    E7 o  ^4 ]) l: _- R
  4 J" b" r7 Y. {: _7 K; ?& i
• 
  
  7 V6 k# o8 @% r- Q& Q$ _void mexFunction(int nlhs,mxArray *plhs[], int nrhs,const mxArray *prhs[])
  ( `! b/ i. Y3 B6 L
  
• 
  1 x/ A; x/ e! Q1 w6 W" A* w
  # U+ S  P) N: U# z0 x* Q/ {& Q) q{
  
  4 ^- t  B$ E( O3 @/ f
• 
  
      double *z;
  8 H) S) K) Q7 e* z. {
  
• 
  ' A! d' Z  ]# }& i; m( v' ~
      double x, y;
  ) x5 c' J4 M+ ^3 R' M0 x/ m
  
• 
  
      plhs[0] = mxCreateDoubleMatrix(1, 1, mxREAL);
  + n9 ]8 m8 ~9 @
  $ G" q& @- a6 g
• 
  
  % m, e+ \- o; e9 u    z = mxGetPr(plhs[0]);
  
  
• 
  . U1 |( g! S! T. |
      x = *(mxGetPr(prhs[0]));
  9 w+ N# ]- J2 v2 P
  
• 
  
      y = *(mxGetPr(prhs[1]));
  ! o  z6 G+ ]5 f( [
  0 A( Q+ t) o4 _; t3 [
• 
  
      *z=x+y;
  
  " D7 n" \0 f+ P
• 
  ; a5 I0 j; G' P5 Z3 ?
  4 @" w2 f/ A& ~0 z; b& k}
  9 {  g7 l+ n( k4 a6 B1 |5 [% B
  % T$ z" y) k0 o- S& Z3 G& ?
  ' s" S4 }. K" [" }/ t* C: Y

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

plhs和prhs其实都是指针数组

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

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

• 
  3 n- R3 Z0 I' e. X
  x = *(mxGetPr(prhs[0]));
  
  
• 
  - f% n$ X% M9 e& e9 M
  y = *(mxGetPr(prhs[1]));
  
  
  3 S0 e0 p" H% D: G% v0 P5 _0 @

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

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

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

• 
  % D- n# z5 W$ K: B$ ?0 M
  ' ~/ z- {: ]; q' }8 n/ v#include "mex.h" // 使用MEX文件必须包含的头文件
  
  
• 
  * q; V( [  v6 L& h
  // MEX文件接口函数
  ( X( c- I0 v$ e7 x% e
  
• 
  5 J* s- i0 \, C% W
  void mexFunction(int nlhs,mxArray *plhs[], int nrhs,const mxArray *prhs[])
  8 o9 O) o# t' N, N: m+ K( q
  2 R9 r7 b6 c6 B  ?! l& ^" H! b4 P) x
• 
  
  {
  - S8 o& F0 [" K; n$ E5 e5 M
  
• 
  
    x- n- g+ n5 O# p+ W    double *z;
  : l" O$ P$ D0 i
  
• 
  " e7 A3 k) E: V# _
  - c9 s9 M3 L& ]0 L    double x, y;
  ' p/ x: B0 n8 U; \: V& T
  
• 
  
  - @- l6 X2 I$ q3 G    plhs[0] = mxCreateDoubleMatrix(1, 1, mxREAL);
  ' m% t4 U/ K* C: r3 q+ E8 _& x, F# q+ \( T
  4 }( @) K1 w/ q7 U( ^) N
• 
  1 A/ T! f2 S' w. Z
  % ^* L+ S* s8 g$ e1 w  H& H! y    z = mxGetPr(plhs[0]);
  
  
• 
  & m' d" R5 x/ R' u8 D
  2 P8 u+ v8 [) J/ {$ V    x = mxGetScalar(prhs[0]));
  
  : e. A9 m& ~3 a! d3 W- }
• 
  
  # E- ], N5 o5 t* P    y = mxGetScalar(prhs[1]));
  
  & d7 g* H' m( [  r$ B
• 
  
      *z=x+y;
  8 \# N5 o8 P( }, ]: f* D
  4 C& P* b, ^+ `/ J
• 
  $ k: M( H6 z( m# }& X1 k
  $ ]6 l  e1 C4 F6 e# X}
  
  4 b7 V7 R' H* a2 ]- e# A
  

(注意：输出参数因为需要通过指针传出，因此这里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" q6 {# }( w) ], k* F" U3 m# f
  ) L) x& S8 f. G* T  [( H/ @" g
• 
  
  void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]){
  ' c* C( n+ A$ p+ Z2 s3 S0 f( d( E% V
  
• 
  5 r. M% M! K  k! F) `
  
  
  
• 
  2 @% x+ `  }, c
  double *data;
  
  
• 
  9 }, c7 }4 w! Z
  2 H# ?0 c6 E" g2 Uint M,N;
  
  9 M8 A& x7 W5 Y% l3 z0 Y# A2 X
• 
  
  " ^* y7 A, K2 Z! \' ^int i,j;
  " H$ A) G9 U2 G3 s5 l
  
• 
  
  4 ~! v+ B; M6 q. g, R9 bdata=mxGetPr(prhs[0]); //获得指向矩阵的指针
  0 s* G1 S, C; v& K/ {1 l& c
  ( o; i# }0 P2 }$ q9 K4 i, Y. @
• 
  
  0 J3 g7 b7 F; s! o' wM=mxGetM(prhs[0]); //获得矩阵的行数
  
  
• 
  ' |+ i8 b  x9 q" N7 I0 l- l1 E
  N=mxGetN(prhs[0]); //获得矩阵的列数
  1 @1 i( B: u0 y4 d, K( E, U
  ! J6 L# I& N( e& h7 ]0 q/ Q
• 
  
  for(i=0;i<M;i++)
  
  $ M2 _0 W) `$ ~/ V, X# j8 R* \
• 
  4 s6 L9 V0 M6 M6 _- [
  4 u% n% S9 x. S5 n{
  
  
• 
  . F/ B" T- F1 M# v
     for(j=0;j<N;j++)
  
  
• 
  % z9 }. M$ e7 M0 z, s5 W
  8 G8 i& h/ Y/ c    mexPrintf("%4.3f  ",data[j*M+i]);
  ; j9 X5 R) m- e5 L# R4 s# K7 `' D/ w
  % c0 u# h. L# L! `' a% j. J
• 
  # L2 m# U& u+ R$ P% d" E
     mexPrintf("\n");
  7 m& n. o* p* ]4 E- O
  
• 
  
  ) @9 W5 B/ U& l: {7 z* r}
  
  6 f% m+ U! t( p0 l7 ^2 O
• 
  * a" O" g" \. m% K' e9 s( O! y
  ; q, o# W+ I6 a# j }
  
  . r! k) N9 J, f4 s* x
  % H* D7 t. G; M  u/ f: z

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

• 
  & ?- H3 l2 y% D/ P
  
  7 U, H3 S* T+ g8 J+ W  J4 X; ~, _
  4 d9 L7 y. p" V" W1 a1 V
• 
  / D6 \; t: x) Y/ o
      double *z;
  % g. F2 Q$ T- E8 p5 ]
  0 L3 ?$ y- w# E1 x/ ]% M* }7 q' P  N
• 
  6 f6 g+ `6 X* j7 Q
  ! l, H0 W! u! B1 T  V    plhs[0] = mxCreateDoubleMatrix(1, 1, mxREAL);
  $ i! ~# [% M9 p
  
• 
  7 Q, [& g+ G' d% N+ T
  $ r- h/ P$ u+ x! o* x! G+ b! o3 [    z = mxGetPr(plhs[0]);
  ! x7 C. k0 W% P
  
• 
  # X  ^6 Z: C, ?, x& z. }! e; M2 j: S
      x = *(mxGetPr(prhs[0]));
  
  2 u+ r1 S6 D7 s/ m% ]& D* I
• 
  
  : n& I' T# G# y) P6 C. ^' Z    y = *(mxGetPr(prhs[1]));
  8 K6 U1 m4 T' n8 D* X* ]6 e& h
  $ H: v. N1 w+ y# B" u" t1 o( N% C
• 
  
  5 S' h4 K) J* Z% Q5 W9 U    *z=x+y;
  $ v+ k6 Q* j, \$ C
  
  . ^* y. A$ o5 }1 C5 T; b3 ?

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

) g, P% K) C0 K5 _; s

youOK

matlab与c语言混合编程