matlab与c语言混合编程

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

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

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

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

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

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

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

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

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

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

举个栗子：

• 
  6 q- ]) ^1 m5 ]; T! J/ I
  + O* Q7 q4 b6 G+ j% D$ D#include "mex.h" // 使用MEX文件必须包含的头文件5 ~. D5 Q1 n; h; T+ m2 V
  ' V7 I- Q3 E9 b# e% Y6 H1 H1 h
  
• / J/ }" H# k' W3 q* ?. q. ]
  
  + G' _0 }0 {: _9 x  i// 执行具体工作的C函数- H2 v9 E1 j6 L& Y# \
  
    M2 w. T% X' F0 s
• 9 y, F7 n+ s* I( _& G+ e1 L
  5 |# V/ j" \$ G, i8 _
  double add(double x, double y)9 b3 D) M% e8 L! z+ m: R
  
  ! M9 \1 C" N5 `/ c' w
• 
  4 }3 Y5 ^/ B4 ~' P! }: y
  5 i' l0 h, u' R7 N{3 i- t7 f" T8 F. _, ~$ I+ R
  
  + s/ T+ u* i- I) O. e
• 
  # ?6 J0 C$ I) ^9 s4 G' S2 ^1 [! u: k) O
      return x + y;9 H1 @7 q6 y# g. f; ^
  
  1 Y0 J3 ]2 ^; b, U& ^
• 4 w+ D- N7 d1 l$ H' |. @' R
  
  ) \& t! x7 I! n* t; \}8 g8 r) k; z, E$ X  q$ n
  
  - K" N- i$ A( T9 D5 B# V0 a
• 
  ! @0 Z$ B! @/ W& o+ w+ S, o/ W
  # O0 H0 w' P1 t4 q// MEX文件接口函数
  + R6 ~& C6 I+ a7 t& C' [* k: r* _+ Z* R  f2 g) I7 ^
  
• 
  3 o: Z/ c, N: w4 v, P) g2 @4 n# [+ Y, w, t% D. `! @4 w8 T& o
  void mexFunction(int nlhs,mxArray *plhs[], int nrhs,const mxArray *prhs[])
  ! o/ T) l8 v* ?0 L9 C, ~5 P+ W
  + b# z: t! z7 i/ ~6 W  }1 \) l1 {3 L
• 
    @5 }; l* Y4 o1 G: y; ?& r
  3 s* b' y7 [. M6 O$ P6 L{
  " {8 E! p6 b: F! f2 R4 i
  / d3 B+ F7 I3 N! d+ ]4 N
• . A  E$ C% [) Q" T$ ?
  8 N9 |' e- e* m4 _! s; i
      double *z;- l7 v8 r, t: H& i% o& c
  ; e3 ^3 g% q# X; l( [: R
  
• 
  ! z% N$ `2 t& C9 z! {
  5 `4 b* S# ]" \5 a! J4 s  M    double x, y;
  ' s, ~2 {3 ?- y4 N9 p+ K7 f+ k8 P- ?9 ^" K1 C6 X! {1 \
  
• $ @+ H7 G# q; m# X9 ?
  
  % y# t# \1 r$ `( T    plhs[0] = mxCreateDoubleMatrix(1, 1, mxREAL);/ |. U$ ?7 T. F
  
  0 c' ]+ G8 F, Z$ c1 z/ H
•   Z3 O6 w* I; K* A0 q- c- ^" Z% Q8 X
  1 e, h1 }2 L* P3 e
      z = mxGetPr(plhs[0]);. `* A) i  u7 y9 n# j9 [
  3 i/ ?& @5 ~( T% [# B3 j7 W0 Z( w
  
• 
  . Z2 C; D& F2 o) N8 s! [% X& U, m  S) j7 B* w( S. ~/ Y
      x = *(mxGetPr(prhs[0]));' A- ~. u6 n$ V
  
  1 N' T- i7 P; O& d0 y# G
• 
  6 x; P9 I1 z* h
  , k7 }( m9 T5 Y) M* x  S    y = *(mxGetPr(prhs[1]));( e0 o4 m! C3 m% F: [- i5 a7 t
  * y' |& q/ n6 r+ }5 v! T$ _6 Q9 L
  
• 
  8 B- X0 G* x1 i6 P9 Z- Y/ X) R/ F
  5 b! \+ h* H, m7 p6 e    *z = add(x, y);% D5 _/ M! I3 l6 c& P, w, i
  ! {& N) l- H4 X7 h* G! d3 a
  
• ' y9 o+ u: i; b) y4 B
  
  ! s2 l, T/ R; n: ^, X- c# n}% A$ `! H4 C$ T* V
  0 b* L+ s" j2 D
  
    w' A# d4 K, h* `0 Z3 R

也可以写成：

• / J  h$ n6 ]) ~4 P
  4 W, @" ?0 d1 a( o) K; N$ Z9 h
  #include "mex.h" // 使用MEX文件必须包含的头文件. g, |' O3 |/ Q' ^  D/ t5 p
  
  - U7 j2 H+ X" P; E; w0 O
• 
  2 I# L+ u2 q3 W9 L1 N0 M! ~' X$ J
  # b6 [7 i4 u2 F; X+ e" V2 `6 m// MEX文件接口函数
  8 [3 }3 M$ }# s6 r
  # V7 @- u0 w' X( Y: j' m" r1 ]
• 
  9 V% u, i$ C% G0 S$ @/ B- V% [  O8 r4 C, f7 F. w
  void mexFunction(int nlhs,mxArray *plhs[], int nrhs,const mxArray *prhs[])6 n# E, w2 E! X; f1 Q2 `8 w
  / Y( ~$ R7 \, u5 d% a2 b9 ?4 X
  
• 6 c, e2 e+ H: q( r
  
  & H& e0 O7 q. u{8 H' s# {& y6 r8 A6 P
  / \% m; z2 O8 c8 |) w4 t0 j
  
• % d( q; O3 v( o! b* l( z4 y
  / Z; G# g2 {0 c
      double *z;
  % a5 W* r- _+ }- _
  + I. f0 c5 }2 j
• 
  1 W  ^7 `. D0 Q+ k8 C1 [+ z, }5 B1 W7 n5 A, a$ Q
      double x, y;. Y" ^0 D! [; J" q( v8 k
  
  . N4 [4 G4 u5 U" N- a
• 2 R2 P. B4 w& f
  
  5 _8 R% l& p; I( T/ _( ]+ k; t    plhs[0] = mxCreateDoubleMatrix(1, 1, mxREAL);+ B' @3 [8 @/ G
  
  5 q( w  o+ Y/ y2 i
• 4 t3 @' |/ v1 J+ r/ q1 y
  
  $ q5 {* n! q' n! U9 M5 E    z = mxGetPr(plhs[0]);
  4 w" M: M- T4 A' e: ?) A
  & s9 A/ S( {9 n0 |& G  S& p
• - [) m! l: N8 Q+ p5 \1 i+ S6 ^
  & t+ F. f6 M) }( D! x8 w" p
      x = *(mxGetPr(prhs[0]));, B: C1 }  G. z! S: i
  ) ~* `7 T3 g/ O& E7 t2 t' f
  
• 
  " V4 h& v0 S2 S( R9 b( p% r3 ]  _- a6 C/ r: `9 d, j5 e
      y = *(mxGetPr(prhs[1]));+ S# i1 O, z5 d% ?- |+ ]# R
  
  , z8 {$ z5 y* c" d6 k! X" w" R
• " v0 s$ A) L' A
  ) q7 P' Z& i. f9 x7 P8 S6 y! W0 y
      *z=x+y;
  0 i+ Z/ @* l1 H- c1 m# F' t- Z$ h' N! N* I3 T( h/ p
  
• 
  4 V" I& u$ ^3 z
  , g& G( c; _' ]7 h$ y}5 U# O8 Y- |! u4 I# L
  % D* b8 L  K. o
  6 h9 Y2 y3 Z. H7 B0 v- J/ j) f
  

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

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

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

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

再调用c语言函数

分工明确。

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

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

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

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

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

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

• 1 E" x6 f* {/ N" a: C( D
  
  8 |& J2 R' ?* {) G#include "mex.h" // 使用MEX文件必须包含的头文件
  ! i7 V3 Z- m- T; `$ z7 G. Y7 \  g( t- W5 f7 K5 Y
  
• 
  ; W" l/ p6 `7 T' k7 A9 P# x/ H; \% Q- v6 j' W) c
  // MEX文件接口函数& \; o1 I/ ?9 K% f% H. M
  
  , z% g3 _3 w) h0 W" E
• 3 U- B2 c# h9 i( X: \) X8 q8 X
  8 [  z0 E* E( m( d1 n! n% q$ i
  void mexFunction(int nlhs,mxArray *plhs[], int nrhs,const mxArray *prhs[])5 X' u- ^- ]5 c1 n- Z- Q
  - v& x7 h; [4 E! ^
  
• % y* ]: }3 L& }. k: i- f
  3 m' Q" E3 t, p. Q! U4 X5 b9 j/ ~3 |
  {
  ( ?! K9 ^% h  P. g( ]0 o4 o( T0 C: s
  
• 
  / b, c4 l8 _9 y  @# A! J2 u$ s
  # \, c9 ]- A8 r. R    double *z;
  - i% A; y$ x5 }' I( Y) e! F' g  h5 v0 [. Y5 j. z2 |
  
• & \6 ?* l7 w) J7 y
  
  & j4 {$ t* e0 x3 _; ~' v& i6 k    double x, y;6 ]9 j0 q! z0 d; l
  
  $ h, H. F3 w! K* I8 u4 ?$ K* p) u+ R
• 9 A0 B+ q. N5 t3 ?, b7 u
    s8 b0 @% e. H1 i
      plhs[0] = mxCreateDoubleMatrix(1, 1, mxREAL);
  5 R% h8 ^1 V9 o* |7 r3 @
  * C( v( b$ r$ R$ E: x
• 2 U% Y) n% q. K7 n* {
  
  $ N0 r9 C; V# M' e    z = mxGetPr(plhs[0]);
  + {+ s& b, w- r5 [% |3 p& P- _3 F3 G
  
• 
  , ^& N) a4 ?& j$ w0 ?
  8 l. ]  o0 N3 e# Y' r    x = *(mxGetPr(prhs[0]));' x. ?8 D, c0 b$ v
  
  1 a" Z% W1 Y3 g  f4 f
• 
  . X! q- K: U" s- r" l8 @( X7 Y' f1 J& A0 M
      y = *(mxGetPr(prhs[1]));
  ( m3 g' q  p( L' \$ C0 n* f/ j/ i+ D$ g; O' A1 D8 j8 U( }. y
  
• 
  . `6 B+ Y- k/ @/ p4 b5 b! R/ T6 S3 v8 F6 U# g% X' h
      *z=x+y;
  / F; W5 H3 O# B3 u0 ?0 l6 h9 v# z4 q0 w) T
  
•   m5 t9 U& `) r$ ~  r( S' j! s* Y
  
  6 S: ?" z; J% f}  O) w) C1 a6 [& d4 P) v
  2 R% y7 {& [% y; M$ y6 j. Y. r3 C
  * {  o$ W$ @1 e0 l7 s, L" g
  

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

plhs和prhs其实都是指针数组

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

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

• 
    a  U$ I1 F3 E) u" ^$ U
  " }0 x/ ^0 W2 V; q8 Ux = *(mxGetPr(prhs[0]));6 s: F* ?6 _+ l6 e7 [  v
  ) v* ^$ t$ f+ n* Z, x
  
• ; w( _9 c4 F( }/ C/ V
  # h; h. a0 Y( |* m6 z
  y = *(mxGetPr(prhs[1]));
  4 H9 A( Q6 ~1 ~# }1 o, f. x+ c9 g+ Z8 T' C: Q6 B
  2 c) @) r% I/ g+ E) J) b5 m
  

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

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

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

• 
  % p" `. O# O: W/ I2 d2 I
  ( M! e4 V, W' \0 R3 `#include "mex.h" // 使用MEX文件必须包含的头文件
  5 \8 |* F, m7 S; |) w, p7 ?9 b3 d% V2 _) _$ r
  
• 
  9 s8 I, W: v, |; h7 A# G- n: q7 Z+ |! j9 e
  // MEX文件接口函数- u. R, d: e4 v8 u  P1 T6 N
  ; m% j9 d- t: e, |
  
• 
  $ u$ P2 B* z0 ]; R. L! ?* G# B! v0 I; y, V3 \4 m. a% Z4 d/ S
  void mexFunction(int nlhs,mxArray *plhs[], int nrhs,const mxArray *prhs[])
  1 G! i; |5 J! T4 R- @
  : H( a: H" f: n1 h. `
• . U, _' v+ G5 {; R7 U4 q
  
  ) ]/ e2 m% g. T+ R7 P{3 H* n; K/ D7 Y/ |# M
  
  ) h- ]: C. x" p0 v
• 
  1 w: w4 c5 I% {; l
  6 d# p) F. Y% L    double *z;, r1 H9 q2 o3 \. k. U+ d
  
  * y4 d! ^' ?6 |$ b; n
• 1 q0 ~9 I, {& L4 M& M0 \
  4 y) z! A4 h7 ~  _2 ^# @) S
      double x, y;
  + R/ q  x' F# z" M- Y1 D" }4 ^
  # I0 L! F- _8 n1 ?
• 4 h+ S5 S. f* E9 u. U7 o. M4 @
  ( e$ X9 w' M( ?- X! [
      plhs[0] = mxCreateDoubleMatrix(1, 1, mxREAL);8 \1 T' R% i+ h. O- G9 S
  % ~7 s/ k0 }! {" l5 h, A2 M5 M
  
• / d& b8 Z( I3 O; k0 z/ {- [/ s
  
  + l& A7 T( Q) ]: K2 v    z = mxGetPr(plhs[0]);
  4 a# V& V+ D, H' n# A* m
  ' G0 `( I9 l2 v5 z
• + [) M2 b) K: t; _# W
  7 L, z# ?2 G/ g8 S$ T
      x = mxGetScalar(prhs[0]));% S  ?! T% t4 j/ \; y8 P# y' A3 a
  
  ( ^* H# l+ n) w, x8 f( _
• 
  2 E0 t3 c0 p+ u1 Z' I, _8 `; N0 g3 s, q) f
      y = mxGetScalar(prhs[1]));0 `4 Y5 {2 P9 }7 R' A% Q6 K
  ) \- Y$ B- O% v% Z
  
• - d' Q! X' Z4 t& U& A" `( K* o
  5 n& k0 X. c0 _% X( z
      *z=x+y;8 ]3 Z, t% s0 A) F
  
  ; _. q( U/ h9 ?1 o8 k9 _
• 
  . _0 V! K' r, T+ ?, o! G* h  R8 D0 t/ k: h+ ?
  }" {+ u, V0 ~: b
  0 S9 ~( @. T7 A! n! s& i
  $ Q3 P$ W0 X3 z. ^0 M) }+ @+ I0 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]

举个栗子：

• 
    }5 Q0 v; C( o" {8 `8 H1 l( ~5 {" p+ g% D7 ?
  #include "mex.h"
  5 P. S0 _! p* V9 W) N% N
  1 a- o' H8 C8 O! d! ?
• 9 r5 P* u/ P0 p7 e& k" @- a- W
  
  + I" S- T$ p) O: {3 i6 _ void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]){" s2 J5 I! k5 ~6 c. B
  % w. ^7 w: X  i/ i/ F' ]+ r
  
• 6 R, W6 ]1 f/ \# w) p1 u/ ^5 k
  
  2 X. p! `$ b2 L$ ^2 e- Q! {9 J6 _: ]+ \7 T' z
  0 E# `2 B# s+ u; _  d
  
• 2 ?* k- P. k2 i" ^  \& X
  
  " b& g+ i1 t/ c% k0 @  W$ Bdouble *data;
    I6 p2 ?; [4 y7 n
  5 a4 L, }+ L8 E- C: Q* ]
• 1 `# ?7 t* }/ H, i# x
  
  # ~2 X2 B4 T+ U3 I' L9 G+ C( ]int M,N;& r* ]3 L5 c, N( R' m
  # R$ S0 Y4 w2 x5 y# b2 z2 q8 d
  
• ! C5 [! ^- E0 A3 W
  
  8 N( \$ d& f/ u2 W3 R$ |8 f/ D$ ?+ xint i,j;
    O) V. O  h, t" P: s: J, Y+ g+ D" e# c2 n
  
• 
  . t8 r7 M3 f/ Z
  & H3 q7 b3 `( j4 ^$ u2 Edata=mxGetPr(prhs[0]); //获得指向矩阵的指针9 _1 |: D/ l9 h9 h8 P
  
  : Q# p. m( Y0 I
• : \3 C' l6 o/ J- ], M; ~! _
  . p& I4 a2 s" d9 b9 P* E
  M=mxGetM(prhs[0]); //获得矩阵的行数' U& u1 M2 ^* C" S
  
  + @0 ~0 v1 Y. C
• 
  + F% ]4 h. V4 e% {" L( O+ L/ `4 {% f+ h, ?; g" `
  N=mxGetN(prhs[0]); //获得矩阵的列数* r7 v8 W9 \3 F" h
  
  9 [$ L$ m! r& \1 D' I
• 
  1 m7 y& ]2 c+ b$ j5 _* j  l1 P% S3 q$ s
  for(i=0;i<M;i++)/ l' s$ j) B/ p( P0 t* K1 n8 b
  
  - Z: G2 [/ X: L+ B1 P
• 
  . S* k: i- d' k6 n: B, U  p5 `$ y3 V
  {
  . P/ }/ F! F  E+ b$ F& M. ^# z; ^8 l5 S
  
• 9 `' o! U' v/ T4 S7 k0 ]
  
  9 t6 L5 M3 y5 @+ |   for(j=0;j<N;j++); h1 ]( i: ^* X" ?
  : h+ u; ^5 Y/ `7 W" t  a) ?+ D
  
• 
  5 r% N! p# W& v/ V3 ?0 U$ P5 \
  , o# O8 q) W. i9 `; i7 v$ |    mexPrintf("%4.3f  ",data[j*M+i]);
  ! |- _3 o$ D  s% T. H4 `, _9 b
  * j; n( R0 }, I9 P4 t1 Z4 x
•   a& _- s/ L. D  d/ i' P
  2 H; S4 @5 g( T: c4 @! J$ ]
     mexPrintf("\n");
  " N3 S+ m3 [- A) [- T; Z/ g( I
  , l" I7 K, b6 p* E; a8 Q# j) ~
• 
  4 g7 K" J! }8 h% N- v
  * B8 e* E9 c1 r! a- A}
  . ~2 ~! ~% u0 O3 W- |( I; v' W4 w6 [0 d. H8 T
  
• 6 r6 k3 E& t& r0 _
  
  - u+ t/ n7 U$ A  x1 X* t  v/ v }& L9 W, \% Y# o
  
  # B' G# H3 W7 x% e0 Q$ Z8 c6 p: m' d! ]
  

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

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

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

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

• # d0 |; H# m; i) B, i$ P
  
  7 Q  Z" l2 Z0 S8 S- A, P5 N* v9 q1 Y) Q" j. U; ?1 b1 f  R5 p
  ! t4 }& {; r* c2 D5 c; b: M; w
  
• : p; }5 z, e* g9 ~% v2 m
  ! _+ u4 X# q% t! t2 w
      double *z;( j6 p0 S! p/ q" S  `& {. d
  
  * [6 S8 h. q- {5 r9 O" j1 m% _1 p4 s
• 
  4 e# K4 V! \2 z: z0 A
  9 w3 M% V. [# ]+ a$ R    plhs[0] = mxCreateDoubleMatrix(1, 1, mxREAL);( G9 b0 h* v% M+ t4 m1 F* W7 E$ E
  9 Q/ v$ }/ `2 k9 U, D! b
  
• 
  - t8 t% N1 d. n0 e/ p9 B, `3 u1 g3 U1 y
      z = mxGetPr(plhs[0]);
  5 f( w# L( |* ^8 u$ I5 Y8 `1 H9 O4 X1 W# Z1 I% |2 C
  
• 
  8 J. v8 M8 D2 |% X! A1 A; Y" K! }
  0 V5 [7 M4 K2 B6 `# L; X    x = *(mxGetPr(prhs[0]));5 ]% m; \. m% ?, N6 @
  ) p( c3 n  E+ W6 @9 \! F
  
• 3 z. ?4 G3 c5 g; K% o6 d. G8 V. t; ^
  + H- e- C0 }  r5 @
      y = *(mxGetPr(prhs[1]));7 H* i1 U% Y5 z9 {5 ?/ K5 t+ K' f6 V
  
  ; J. T7 E$ J" ], ^
• & F# R. G4 K5 n# a- V$ E
  
  1 I% _8 k7 |& D: E+ {- k" A1 ~) N4 B    *z=x+y;
  ( S9 |9 }+ Y4 k& _! r( m3 `8 x3 N* c% G3 B8 o; ]
  ) z9 Q5 H! \, P+ `9 o, e
  

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