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

" P% J) ]/ M5 m4 ?1 |- 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[])

举个栗子：

• 
  ! G6 ^/ S( A  a% E# {
  / Y. Z  p4 b$ Q8 g9 r# H5 ]#include "mex.h" // 使用MEX文件必须包含的头文件
  4 g5 B; R$ k1 c8 M+ l: G6 Z
  
• 
  7 j  N/ j, D' l
  5 N* b$ c9 j" \9 [6 c# o% _// 执行具体工作的C函数
  
  
• 
  ; K1 t+ }- Q4 y- H
  , ?* k5 m: h) K* \& g; odouble add(double x, double y)
  
  
• 
  
  * a8 |: b8 T+ g0 {; n5 R2 V6 ^{
  7 e1 V" J: E* L' q8 o& I# m' f* |
  : @9 C% a! |# P% C+ K8 \
• 
  
  ' f& I& v! s( q; B+ ~+ Y    return x + y;
  4 [; h/ n. m5 n& E0 g3 S
  
• 
  
  1 `' H4 y% I3 Q}
  / W0 A' q& K* k' v' I) o  v
  
• 
  
  & B. p+ ~" M1 l// MEX文件接口函数
  
  
• 
  
  ) R7 c) N) x. H9 ?* `# @void mexFunction(int nlhs,mxArray *plhs[], int nrhs,const mxArray *prhs[])
  % s5 ~+ x/ f9 H4 \
  
• 
  
  {
  
  + y  k) \) N) k
• 
  
  1 h" e8 T) X6 c# v2 W2 Q& j    double *z;
  * g  o# K! L0 @7 s% H
  % y. j! B  j* H& J
• 
  & T' Y$ o) @# K& y- ~# H2 V* G, W+ p
      double x, y;
  
  
• 
  9 f% G; X+ F! k* p+ I+ D
      plhs[0] = mxCreateDoubleMatrix(1, 1, mxREAL);
  
  
• 
  
  6 i4 C+ J4 A4 K3 N1 ^6 a$ `    z = mxGetPr(plhs[0]);
  
  3 g0 Y8 l$ E" K! b1 P- ?- E
• 
  . i) z! i- y6 k* ~! l
  7 b; b) @1 M/ F8 E8 ~# Q    x = *(mxGetPr(prhs[0]));
  * a8 i# _9 Q- q' K% B) V& I/ r
  8 S0 V7 n6 d7 U6 ^" \/ E- t! v
• 
  0 U/ x3 I1 f/ E
    ^8 i5 W' u$ i1 G9 p8 S    y = *(mxGetPr(prhs[1]));
  
  
• 
  
      *z = add(x, y);
  
  
• 
  - i1 L+ M2 I# U
  }
  " X+ Y7 d7 a7 E5 O$ y6 m
  6 p  @. F" R; E* H6 w. [) ]: V
  / p2 C% [, O2 }

也可以写成：

• 
  
  #include "mex.h" // 使用MEX文件必须包含的头文件
  
  
• 
  
  // MEX文件接口函数
  0 E' S# n1 Q! V& s/ y* s; \
    Y" N9 p  P6 m
• 
  
  ) S# ?( p$ A. E, N1 W! t$ R2 kvoid mexFunction(int nlhs,mxArray *plhs[], int nrhs,const mxArray *prhs[])
  * P- _$ ^9 `# d$ M9 w6 W! t
  
• 
  
  * m4 B8 h5 f' I) T- s{
  
  
• 
  
      double *z;
  * ^8 y  n+ d; L. c3 T( |7 W& N
  * u0 G# d  u, ~% c6 V5 Q" p
• 
  
  0 D6 m- C3 @' E  i" a3 V9 }( S    double x, y;
  ! ~8 o0 U# p* e5 {/ S
  " ~( [! q; g( q$ m2 e
• 
  
      plhs[0] = mxCreateDoubleMatrix(1, 1, mxREAL);
  ! w3 _. ^$ w+ y, f% b
  
• 
  4 D2 s; I  E: \2 |' C+ E6 V! g
  % w: P9 x: c# @! C1 d    z = mxGetPr(plhs[0]);
  8 A, B  O, h5 D6 n+ ^
  ; y- z. q; {8 f
• 
  7 [+ Z$ R, }- F
      x = *(mxGetPr(prhs[0]));
  
  . g0 D# W+ z* c$ Z
• 
  
      y = *(mxGetPr(prhs[1]));
  
  
• 
  ; o( `0 y2 O" L) }- U
      *z=x+y;
  ) O" m- o" P7 j* {# R
  5 ]+ w) d5 C5 I  J/ P. C
• 
  6 g; _6 t: k# a# e
  $ z/ v; R9 C+ O" W}
  
  - Q1 C1 U$ N7 ~" T" Y7 P. t7 e
  

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

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

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

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

再调用c语言函数

分工明确。

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

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

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

参数

意义

英文全称

类型

. H. w; u: F, m* E3 \$ Z9 Knlhs左边输出参数的数目number of left-hand side整型（int）
, [+ c2 @3 U0 G' k2 Z* m2 gplhs指向输出参数的指针pointer of left-hand side指针数组
  n2 \* O9 B  I, ^: z' qnrhs右边输入参数的数目number of right-hand side整型（int）
+ ^' D- o: U6 A+ j9 k1 O5 a, ?prhs指向输入参数的指针pointer of right-hand side指针数组
, H7 n* O/ x  s$ ~

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

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

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

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

• 
  
  4 X3 {% c% G6 w9 @/ U9 n( S#include "mex.h" // 使用MEX文件必须包含的头文件
  / ?+ c  f, Y* |: I# w8 O
  
• 
  
  3 n; M8 }7 g: I4 ^// MEX文件接口函数
  
  
• 
  ' M! M6 r- t! l, y" _9 Z* E, a
  void mexFunction(int nlhs,mxArray *plhs[], int nrhs,const mxArray *prhs[])
  
  * k% U/ c8 [+ M" H- K4 V
• 
  
  {
  - N8 u, {+ x* B- w' T2 e
  
• 
  5 D1 d6 C: l1 R3 i/ i
      double *z;
  
  
• 
  
  + O, G: J) B9 P, @3 z8 k7 }    double x, y;
  ( d( h/ A6 f, X8 O" S
  
• 
  3 c- n7 R8 R& s- G+ Y
  ( l5 c, s2 p6 q+ q, [4 y    plhs[0] = mxCreateDoubleMatrix(1, 1, mxREAL);
  4 [; K. ~0 e. q# u% V0 g4 k  F. `
  . Z! [' V4 z8 y7 s2 K: B
• 
  
      z = mxGetPr(plhs[0]);
  
  
• 
  ) q8 b. p" e. f/ C% s4 c: i
      x = *(mxGetPr(prhs[0]));
  
  
• 
  3 v3 P/ [6 M: v; c, J+ a/ r) w" u
  ! a5 s! R* M2 o7 b6 p, G    y = *(mxGetPr(prhs[1]));
  ( k% n& z" ]9 i6 D
  6 H6 `( I, M  F' g  Z8 h9 j' Q1 Z
• 
  - e% C" O  V  y; {- i) l8 I
  ' o* @8 }( L: B& A% }0 v* _    *z=x+y;
  ' T$ D. X; l+ b" \4 c' D7 w) Y
  . T' H; n+ R& w5 P
• 
  
  % I+ s# G, b4 r! Y% n  f; Y5 L}
  
  # p. ^- w+ N6 Q( v$ z% H
  

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

plhs和prhs其实都是指针数组

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

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

• 
  
  5 g2 |' u# L' a1 ?x = *(mxGetPr(prhs[0]));
  ( k0 I( @# D9 U" ]5 b$ h# k- N
  
• 
  + W3 _. H" {: g; ?* S  T
  y = *(mxGetPr(prhs[1]));
  . i" O5 V2 T% y- B
  & z( a( n( f+ ^( F0 X$ h/ Y
  8 n7 c/ J3 C3 n% k4 r" |; l2 b6 p

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

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

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

• 
  
  #include "mex.h" // 使用MEX文件必须包含的头文件
  1 R6 n4 j+ k  d" f, C( o
  : l- K. x# G& K1 l; j6 O0 w
• 
  . Q- M5 L/ ]& K5 v& x, Z! G
  // MEX文件接口函数
  ; ~2 ^6 Q7 S# L# T5 K' h7 I
  
• 
  
  void mexFunction(int nlhs,mxArray *plhs[], int nrhs,const mxArray *prhs[])
  
  
• 
  
  - h+ W' f6 ~, z8 r+ h. S( W{
  
  
• 
  
      double *z;
  
  
• 
  ( b  W6 ?  H) D. H
      double x, y;
  
  ! H  |9 |6 U! U
• 
  : o: q7 V9 D- N2 _, w
      plhs[0] = mxCreateDoubleMatrix(1, 1, mxREAL);
    q( m4 j* Q$ o; j9 W4 z3 z& @! N
  
• 
  7 u6 b1 Q9 o" X3 }" O) A8 m" E
  8 ^% T' P, q+ e/ a    z = mxGetPr(plhs[0]);
  
  
• 
  
  7 l( H, a8 L- J# o3 j    x = mxGetScalar(prhs[0]));
  
  
• 
  
      y = mxGetScalar(prhs[1]));
  
  
• 
  
      *z=x+y;
  
  
• 
  
  }
  0 `# `- F0 ~# y; B: S% h
  9 o! d) s9 e2 p( }: c
  

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

举个栗子：

• 
  # Z7 G2 U% Y4 Z9 p6 l. l: [: J
  #include "mex.h"
  
  . L! M% I7 d5 j% Z' O
• 
  
  void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]){
  
  $ D5 ?6 s) m8 X5 n& ]; w8 m# x! X
• 
  5 c* `: C2 j! }, d
  6 z# G# n) c8 @7 D
  - K. J+ J; [: x9 D5 T
  + h1 R8 v: Z/ N
• 
  
  double *data;
  
  
• 
  5 c- V( u) U" ?6 H$ o+ J: x
  - L$ N8 S( @8 Nint M,N;
  / v4 S2 @7 o, C6 B) z1 {' ~  m$ i6 X
  
• 
  5 `: T! y* u; E5 L
    |9 ~% D. x) q2 [int i,j;
  
  
• 
  ' ^# D( U) z* E$ Q, ?& D
  data=mxGetPr(prhs[0]); //获得指向矩阵的指针
  
  ( K  a2 i+ E: T, b* X. \+ x
• 
  
  $ x" n' b1 O, _M=mxGetM(prhs[0]); //获得矩阵的行数
  5 }' T  d; S1 }) ~9 z
  9 O( I# Y) j. I8 |* i* P
• 
  
  N=mxGetN(prhs[0]); //获得矩阵的列数
  
  
• 
  
  for(i=0;i<M;i++)
  
  ) \& I  z, B4 v7 o& s2 L& |. Y
• 
  ' G$ ?0 z8 a0 r) ?
  ( P# H( k$ q9 m) T; l( N{
  % T9 r( X3 Y: X8 A" ?
  
• 
  
  / k) l( H' Z0 m5 c) b   for(j=0;j<N;j++)
  
  
• 
  4 v1 B0 j: w" r3 S$ `/ ~8 o
  4 l& q- Z+ o- m6 G' k    mexPrintf("%4.3f  ",data[j*M+i]);
  3 w* f& A# n7 i; j( M3 E
  1 A) m2 d" a. T4 T" C
• 
  
     mexPrintf("\n");
  3 L0 ?6 X( L) T) Z9 V4 V
  ! l" R3 J7 m" t+ E  e$ S8 J9 g0 C
• 
  
  + C  i2 x+ h  _5 U6 F6 _}
  / }: T$ G" H2 `$ ]$ Q+ S$ Z7 j
  
• 
  7 [4 I" I6 Q# O7 k% ~) s3 F
  }
  
  * `- R( [( J6 }
  & b3 O3 S, X, d9 `/ {" R! q. e

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

• 
  
  - p/ G2 p' H6 {& U2 J! r9 R
  
  & {; O5 N' Z. M& [' u
• 
  0 d% ]; K0 O4 p( F" }
      double *z;
  1 g) G9 I" b, |; ~9 l  W
    j4 v+ f" ~7 E/ I3 R0 o4 |* N
• 
  ; ?- S" ]% R& M
  4 d* I- j, Y" p6 Z2 ^7 {2 n! f    plhs[0] = mxCreateDoubleMatrix(1, 1, mxREAL);
  
  
• 
  ) p2 W; w" V6 t' X
  ) H* {& M( L3 |: a' D$ R/ _) O    z = mxGetPr(plhs[0]);
  
  1 Q  f$ l2 U: a8 }$ s  U) X6 X4 s
• 
  ; {. _' s& p6 l, G/ c8 M
  * ^+ f- Y" L, K+ ^' e7 E" Z    x = *(mxGetPr(prhs[0]));
  8 y+ M0 U, p/ n$ T
  9 a4 P+ c# J$ S3 |
• 
  
      y = *(mxGetPr(prhs[1]));
  3 k3 z9 U) W5 B: \8 s
  
• 
  
  & h7 @6 l" Z1 o  N6 ]. c    *z=x+y;
    o+ n* c# {+ F1 a
  
  + m4 {+ V) k) D6 `2 \* \

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

1 N5 x& t( N; X7 A& C

youOK

matlab与c语言混合编程