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

举个栗子：

• 
  2 ]9 X* K( S3 c
  #include "mex.h" // 使用MEX文件必须包含的头文件
  
  + ^. Q9 J5 p6 a$ |9 M
• 
  % h: Z/ T2 L$ ]1 N. V" u( s  T2 y4 X
  0 X& e2 m. L1 r6 v, b6 ^// 执行具体工作的C函数
  6 H: W3 t8 j! ~5 _
  
• 
  
  double add(double x, double y)
  
  - k# D( j7 O  ~
• 
  
  {
  
  
• 
  0 M2 ]4 F" Y  Q9 x* P. H5 \
  % l1 j$ x8 K- C$ n+ A  ]2 W    return x + y;
  : a" j8 z; v! j5 M! K
  5 c; L' R# E6 o4 S; y
• 
  
  }
  
  ) B( A3 K6 q0 ^; u) q9 O
• 
  ( n" p# x  a* n$ f) r5 W) j
  // MEX文件接口函数
  
  
• 
  
  void mexFunction(int nlhs,mxArray *plhs[], int nrhs,const mxArray *prhs[])
  
  $ ]7 }% i6 P; r6 D4 {; I2 t
• 
  
  {
  8 k/ \0 k& n5 n
  8 M" v0 z) d8 i5 @
• 
  
  0 ^$ c, q3 F! N! x1 c    double *z;
  
  
• 
  / m; v) [. P; F+ A
      double x, y;
  9 V# a, W4 s- @& ~( x. `
  
• 
  
  4 a! k! n! A3 S1 m    plhs[0] = mxCreateDoubleMatrix(1, 1, mxREAL);
  # }. `! N6 Z& C+ j% \
  
• 
  
      z = mxGetPr(plhs[0]);
  9 c+ w, _: m- d9 g
  
• 
  
      x = *(mxGetPr(prhs[0]));
  
  
• 
  * i2 F- W6 O; P' h! d! i
  2 P# O8 ]- ^+ a& T    y = *(mxGetPr(prhs[1]));
  
  
• 
  
      *z = add(x, y);
  9 ^( i; Q6 }& ^$ O( I5 q9 W
  
• 
  
  }
  
  . W$ ?8 W7 B' ]! y9 ?' m7 l
  

也可以写成：

• 
  
  % a4 E& U6 [) Z' w* T, z#include "mex.h" // 使用MEX文件必须包含的头文件
  - M/ B; r% \- `( l
  1 A! ]$ _/ q/ o; h$ m
• 
  # H: G9 t4 x2 Q/ r) G1 ~
  ' Z% z, P' x& p$ J7 n8 E+ D// MEX文件接口函数
  
  
• 
  
  / Z9 g: l. H5 V8 F: ~5 {/ Z1 Mvoid mexFunction(int nlhs,mxArray *plhs[], int nrhs,const mxArray *prhs[])
  7 y0 f) ^: Q# P5 x+ ^1 F
  
• 
  
  {
  
  / V/ ^& [$ T% \& ?4 K  d+ o
• 
  , s3 r7 ~- R' {  M# g
      double *z;
  6 {8 {; g4 h/ I" C! |
  ' Q* D' v- ~, S- d
• 
  - t6 H$ N' X. h- R/ D6 z
      double x, y;
  # f# D" a+ k2 M1 k6 }
  ! Y( ?9 x9 _* y
• 
  
      plhs[0] = mxCreateDoubleMatrix(1, 1, mxREAL);
  : i0 E% ~+ A4 z' Q' T
  - E4 d: g6 {$ V
• 
  
      z = mxGetPr(plhs[0]);
  " `( o7 ?  M- m$ T6 E4 E
  / M; p; w: K0 R/ j2 w
• 
  1 h4 G( v! i+ i2 v% J# Z) r8 C( r: [* H. u( R
  ! v+ `9 q) m: G& _  C  V    x = *(mxGetPr(prhs[0]));
  
  ! M8 d# B1 P5 S0 r% S, D( |
• 
  
      y = *(mxGetPr(prhs[1]));
  ' Y$ ^0 R: @% d* N- @" M+ N& Q
  
• 
  8 u3 U) ?! Q+ V1 M7 w
      *z=x+y;
  0 n, A* f& r! [" }# B. W9 o
  / t: K  H7 C# D
• 
  
  }
  
  - V# J/ o* t; L
  

也就是说执行具体功能可以通过编写一个独立的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指针数组
2 n( j( Q" m) w/ Hnrhs右边输入参数的数目number of right-hand side整型（int）
prhs指向输入参数的指针pointer of right-hand side指针数组
" ?% x4 E% d0 i/ V, I0 O& [% x# [

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

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

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

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

• 
  
  " g7 O3 j! q% @) X7 z' N#include "mex.h" // 使用MEX文件必须包含的头文件
  
  * o, j2 n$ ?) c; O4 b8 [9 l
• 
  
  // MEX文件接口函数
  
  1 m" b5 B! \* d6 j6 }' u
• 
  7 c+ Q& t" r3 r. h
  void mexFunction(int nlhs,mxArray *plhs[], int nrhs,const mxArray *prhs[])
  # U% ]/ O0 h  J9 Y9 H& }
  / K7 p/ ]/ X: @5 f% E' J9 `0 b
• 
  - l9 `+ H: ?/ B0 |" J2 `3 y
  {
  
  
• 
  
  " e. o2 @. d% E2 [8 C8 }% |7 c' K    double *z;
  
  
• 
  : W1 R. i$ J  ^; p; P% l5 H
      double x, y;
  
  
• 
  ' \; o) b# ^3 M& H; n% O
  5 g9 [+ ]" _2 E; C: K5 l/ h    plhs[0] = mxCreateDoubleMatrix(1, 1, mxREAL);
  * x( N$ ]& z3 S. x
  1 z3 V0 o4 z3 w- Q
• 
  
  0 c8 e" {! T5 S1 x    z = mxGetPr(plhs[0]);
  
  - _' U& H9 `' N  ]
• 
  , v/ q: r+ X! `3 o6 ~
  / d2 X( `. s3 F% k7 H2 U    x = *(mxGetPr(prhs[0]));
  % R1 }# V3 I1 `4 s6 B0 a
  2 D+ x3 ]$ H; M5 N: I) q
• 
  
  : [8 G: L* d* k/ A" q1 N! K* k# C    y = *(mxGetPr(prhs[1]));
  
  8 y/ Q' i( s& O- y# ~5 Z0 U0 E  l# X4 n6 A
• 
    ~2 \* v6 D, v
      *z=x+y;
  1 D" u& Q% T  @* c
  , m' q6 _, D1 N
• 
  
  5 @+ ?: Z) u- p0 J# s}
  ; M6 G9 w' s0 {( m+ {
  
  6 ]  x& U4 ]5 N/ q# _

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

plhs和prhs其实都是指针数组

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

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

• 
  5 e1 E$ J/ }# v" p4 Q
  5 \- Y7 U  K- y( Y5 f8 Bx = *(mxGetPr(prhs[0]));
  0 }$ V% M) _+ m( n
  
• 
  
  : K- P' E# m# H+ W: N5 H1 v+ y8 qy = *(mxGetPr(prhs[1]));
  3 E7 @; U& g& m% G$ U
  
  

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

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

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

• 
  # e7 R. ^. B9 U6 U
  #include "mex.h" // 使用MEX文件必须包含的头文件
  
  
• 
  ) P; S, U; Q9 d! d
  4 I% B- @0 K2 I/ n// MEX文件接口函数
  
  / p% w3 |- G0 O6 j  j1 z
• 
  9 S: ~2 a8 h2 c0 Q+ [
  void mexFunction(int nlhs,mxArray *plhs[], int nrhs,const mxArray *prhs[])
  4 ]( o3 Y0 Z7 u: O
  + E- H! w) S0 g; |" ~
• 
  5 P& d" W8 Z! Q
  9 A* e, v/ M" F5 C7 U- ~{
  
  
• 
  
  ( e7 E# D4 z( ^0 x0 p) g6 m+ j    double *z;
  + a; ~5 {) b7 l; t" C
  $ V# `- S$ C. u
• 
  
  ! G' p1 [6 Y' x3 |2 D/ }( _( w    double x, y;
  , E7 w+ U1 e7 i* n; R( w
  
• 
  
      plhs[0] = mxCreateDoubleMatrix(1, 1, mxREAL);
  
  
• 
  
  + u4 a# x1 q( M    z = mxGetPr(plhs[0]);
    H% t' _8 l+ }7 H7 d
  7 j) _  G5 _6 |
• 
  3 d/ {$ g; l$ j# X$ F( e: _
      x = mxGetScalar(prhs[0]));
  9 P& @' x! N6 V
  
• 
  
      y = mxGetScalar(prhs[1]));
  
  , {1 Y4 l) W! e/ X
• 
  5 Z  o: I9 }) G* C: B; W0 [
      *z=x+y;
  
  
• 
  , F1 Y, k" X2 a. ?7 y
  * g- Z8 `1 {1 s" Y0 A}
  
  " D3 w/ n7 f* u
  

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

举个栗子：

• 
  
  - z% s! o5 t5 T0 }. K0 j  Z! G/ y# N#include "mex.h"
  
  % K5 q: {- J9 }1 @: D  O9 R% E
• 
  9 C3 _: l4 D& @
  void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]){
  
  
• 
  : x0 q- u  i# z# }  q
  
  
  
• 
  
  double *data;
  
  
• 
  
  " \$ K2 r* F7 {" Y7 aint M,N;
  : e+ i, L, M9 ]8 f
  % ~% r4 s  w$ z6 z
• 
  
  int i,j;
  
  8 P+ A9 h' l  t
• 
  * u2 b# O' F; V6 P7 j1 g% \* D
  data=mxGetPr(prhs[0]); //获得指向矩阵的指针
  ; ~6 ?  x' m+ o+ |$ x; h3 R
  " ]. K$ _$ d7 h/ Y  _" C% \
• 
  
  / T, P+ r6 _- d) S! D. u1 hM=mxGetM(prhs[0]); //获得矩阵的行数
  
  
• 
  
  N=mxGetN(prhs[0]); //获得矩阵的列数
  7 b2 l, a( K2 C. g' u& o
  
• 
  : P0 Q' `# `) W
  7 e9 W3 W, a. z' C5 P2 Gfor(i=0;i<M;i++)
  3 v/ ~- p2 u1 g' {7 {% h9 B' }% ^3 q' j
  
• 
  ! |: T7 @  }  _% z. O3 S: ]4 F% S
  {
  
  / {( d1 i& a3 @9 U
• 
  / `5 u) [+ B. Y6 m+ R+ H8 k
  * k! R( Q7 i' j% r   for(j=0;j<N;j++)
  - P( l& D  s5 w& w0 I* V! L
  
• 
  % T1 Z4 a, H- p( z
      mexPrintf("%4.3f  ",data[j*M+i]);
  
  # d3 @; b# {  a' ~
• 
  
     mexPrintf("\n");
  
  
• 
  
  8 h6 J4 K$ w1 ?3 q: u# D0 E8 ?}
  
  1 Q0 i" S6 j( Y, S
• 
  
  }
  
  
  

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

• 
  6 m3 K" m5 r; P- q; \2 c
  % J& ^/ X- s2 U5 y8 m
  ' R$ ?  e) R; x3 a* d
  
• 
  & x) `; t* _5 p3 o+ e: H. i
      double *z;
  
  $ ]  F! [" ]& l2 W
• 
  
  3 R% e, J! X2 H( m% p, Y7 e2 o( ]    plhs[0] = mxCreateDoubleMatrix(1, 1, mxREAL);
  " M! n/ V2 d$ o% i0 g; f
  
• 
  2 m7 q4 Z# C! W
      z = mxGetPr(plhs[0]);
  4 i" _9 \+ S1 D# y7 H! r" Y
  
• 
  * P- _& @& A: m( B8 `
      x = *(mxGetPr(prhs[0]));
  ( A  v) z/ w! C4 _2 w7 {0 x
  ! L" O5 A  I. u# O& z: n
• 
  
      y = *(mxGetPr(prhs[1]));
  ; ]5 C6 y2 H1 y" @
  1 q5 K2 i: w/ E+ x  Q
• 
  
  " K( f  i( M) z- \, |4 [5 R    *z=x+y;
  ! M3 r( z+ C' s' }( u3 w
  , F8 y( U/ {4 a8 S* S+ Z9 z, q, c
  

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

. q1 p3 R' ~  p4 e2 o/ A2 h3 N

youOK

matlab与c语言混合编程