| 
前言:
x
EDA365欢迎您登录!您需要 登录 才可以下载或查看,没有帐号?注册  众所周知对于循环这种运算,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 Z6 H! t, s2 q, N
 
7 j  N/ j, D' l
 5 N* b$ c9 j" \9 [6 c# o% _// 执行具体工作的C函数+ D: i6 }, ]9 H& O/ @* H7 z9 n4 j
 5 i7 T! U. n" I- ^  M1 x2 c& g
 
; K1 t+ }- Q4 y- H
 , ?* k5 m: h) K* \& g; odouble add(double x, double y)6 B. L  I6 y* t0 Q% u2 F& t/ ]
 - Z8 h& u0 M4 v) i% ~3 R2 k# P
 
0 ?2 J$ O' U. G2 g1 g
 * a8 |: b8 T+ g0 {; n5 R2 V6 ^{
 7 e1 V" J: E* L' q8 o& I# m' f* |
 : @9 C% a! |# P% C+ K8 \
- Q" W4 t7 }$ M% L) i* C  V+ b7 e
 ' f& I& v! s( q; B+ ~+ Y    return x + y;
 4 [; h/ n. m5 n& E0 g3 S5 G! X* N! f0 N! z3 H, X. k
 
+ z3 M8 g" _5 h2 D& m7 g
 1 `' H4 y% I3 Q}
 / W0 A' q& K* k' v' I) o  v3 T3 c) h$ A/ q0 D2 b
 
+ h* ~8 A; p  w- P6 |& F
 & B. p+ ~" M1 l// MEX文件接口函数  n1 w* ?! W8 d% M) o' g
 # Z6 |( E3 G% F# I# M2 Z2 R
 
" U  G. b# ^/ D! H$ X0 J6 k
 ) R7 c) N) x. H9 ?* `# @void mexFunction(int nlhs,mxArray *plhs[], int nrhs,const mxArray *prhs[])
 % s5 ~+ x/ f9 H4 \* M" x- A1 C( ?- r
 
8 r  B0 _$ t; w( }' ~( j8 Y5 n% h- ?, a$ P6 X5 ]; Y. q0 p! e" i  L
 {' e& Z8 e. ~% ]
 
 + y  k) \) N) k
4 n1 a# u4 x5 G) F* m( z# w
 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$ b# B7 h' l2 c# f
 double x, y;. f% e3 s0 n3 u5 r
 , z, y# K) j9 U; _
 
9 f% G; X+ F! k* p+ I+ D' \1 J2 x% a" O
 plhs[0] = mxCreateDoubleMatrix(1, 1, mxREAL);% o6 [& v  Y+ L! h9 C  t: P: J
 , S9 c" v# q, U7 V$ T+ H9 G
 
4 @, L+ J: R& M
 6 i4 C+ J4 A4 K3 N1 ^6 a$ `    z = mxGetPr(plhs[0]);, s! P( \# W' x8 `6 L* e, j
 
 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]));) F8 t& o7 l' q% f
 3 ]8 d. j% x' h8 K7 A) {5 E/ N, D
 
  |4 ]4 N! h5 j5 @  R8 R  r' w5 ~1 `+ C1 Q$ v- Q7 k" v
 *z = add(x, y);7 t8 L9 @5 ?6 K
 6 B& Z, M9 t1 p( m. m9 s
 
- i1 L+ M2 I# U% V, y2 S) Z7 j6 |2 D: t
 }
 " X+ Y7 d7 a7 E5 O$ y6 m
 6 p  @. F" R; E* H6 w. [) ]: V
 / p2 C% [, O2 }
 也可以写成: * G0 K& c! |7 v1 g4 T/ ^- q! I: E% G) m& t# G' T" A% {! H
 #include "mex.h" // 使用MEX文件必须包含的头文件: J, W# i  F- a3 }
 8 q0 P, E. P& O
 
: w2 ~0 b. {4 c" w% U4 T5 u/ z* \# [/ z. |
 // MEX文件接口函数
 0 E' S# n1 Q! V& s/ y* s; \
 Y" N9 p  P6 m
* U! y  |0 C6 |7 A0 t
 ) 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! t8 Z/ L# }( F( H; q1 W- I
 
2 M# Q* F' X) g  U
 * m4 B8 h5 f' I) T- s{4 ]: {- Y# {) n$ D& B
 - ?$ [( _2 L) r6 S# ^
 
2 g5 I) C% G* c+ V  b. b+ M' m. v% o4 E9 j+ @1 C  W5 F4 X! R! K
 double *z;
 * ^8 y  n+ d; L. c3 T( |7 W& N
 * u0 G# d  u, ~% c6 V5 Q" p
3 F6 ~8 a7 B. m0 z5 ^6 J
 0 D6 m- C3 @' E  i" a3 V9 }( S    double x, y;
 ! ~8 o0 U# p* e5 {/ S
 " ~( [! q; g( q$ m2 e
9 ]3 h( Y) c+ B- @" \5 u) j5 ~3 n% Y+ f
 plhs[0] = mxCreateDoubleMatrix(1, 1, mxREAL);
 ! w3 _. ^$ w+ y, f% b6 a7 g& v' y; n' F! G
 
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/ ]- _2 U. a7 w
 x = *(mxGetPr(prhs[0]));  m1 u* e7 g* r. L: Y. I- X) K
 
 . g0 D# W+ z* c$ Z
% l4 X& |5 I0 R5 N% |0 F% d/ T) s* M) Q* d1 m" X" K- D
 y = *(mxGetPr(prhs[1]));& X! f* ]0 t' e) D" x
 6 L+ l1 u( {: C. B( R/ K) M# X
 
; o( `0 y2 O" L) }- U+ g* S. E. L5 A# Y1 Q/ y
 *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}/ b9 P4 B, K1 n( d& u0 j  p
 
 - Q1 C1 U$ N7 ~" T" Y7 P. t7 e0 v- n5 e9 i; W+ u8 Q
 
 也就是说执行具体功能可以通过编写一个独立的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中大多数数据都是以这种类型存在。 还是拿之前的栗子来解释: % |6 e3 h. ^2 q8 v* \$ ]5 E
 4 X3 {% c% G6 w9 @/ U9 n( S#include "mex.h" // 使用MEX文件必须包含的头文件
 / ?+ c  f, Y* |: I# w8 O  C' Q( z( p$ I" {* P0 y, V( b) ]' L  J4 a
 
) J9 @" r2 V; F: B6 O
 3 n; M8 }7 g: I4 ^// MEX文件接口函数5 q4 N2 K0 k4 O( j6 B
 ]1 E7 V) E! c8 p1 {
 
' M! M6 r- t! l, y" _9 Z* E, a$ L! _9 A; c/ D4 _- o0 z0 ~7 {
 void mexFunction(int nlhs,mxArray *plhs[], int nrhs,const mxArray *prhs[]), H+ p' R! ^/ J: A* P$ Q2 {
 
 * k% U/ c8 [+ M" H- K4 V
4 |* D, H9 U1 a* F  l3 j8 o- g& ~; N$ T3 Y5 J. _: }
 {
 - N8 u, {+ x* B- w' T2 e- h$ h% W/ p, `+ X* ]1 p7 E8 s! t
 
5 D1 d6 C: l1 R3 i/ i# W% J4 t( ]! I; E; B1 Q
 double *z;8 [" c% j' F/ \, I
 7 X0 o3 z4 f1 {. w+ ^
 
* c4 o. m7 |6 K
 + O, G: J) B9 P, @3 z8 k7 }    double x, y;
 ( d( h/ A6 f, X8 O" S( L- q" N& Q* Y4 [" }  _; U$ }: R3 i
 
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
! F) b; z2 m# p+ L+ H4 N* k, c) D8 j# f$ t( D
 z = mxGetPr(plhs[0]);8 W; r( H: Y) `
 # k" n  x6 F1 F
 
) q8 b. p" e. f/ C% s4 c: i" _( Q* A' U" s. u! @. z  C$ v- s
 x = *(mxGetPr(prhs[0]));) f2 c9 m: U- g' S6 T# ]
 : U2 _: B. Q0 ]1 [7 h1 h
 
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
  O  i/ @  Z7 S5 j9 v8 c
 % I+ s# G, b4 r! Y% n  f; Y5 L}9 b" T$ U  [! K# x# ?" j5 I2 Z
 
 # p. ^- w+ N6 Q( v$ z% H2 K* f# c' L7 y% ?
 
 在这个栗子中,输入参数是x,y,输入参数是z(虽然没有返回) plhs和prhs其实都是指针数组 prhs[0]代表指向第一个输入数据的指针,mxGetPr代表获得这个指针,后面再加个*就是c语言里面再正常不过的按指针取内容了 所以就这样x,y通过下面这两句传入到了mexFunction中 0 i* A7 I0 \0 w% h: D
 5 g2 |' u# L' a1 ?x = *(mxGetPr(prhs[0]));
 ( k0 I( @# D9 U" ]5 b$ h# k- N# C/ Q3 i% p3 d* `! D& O! U
 
+ W3 _. H" {: g; ?* S  T0 M: U; L. R6 b/ f
 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改写: # u$ d$ ]6 X" w; Y3 L, F; c+ I0 t- K9 x3 t8 K
 #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! G6 `' q, N$ U9 ~
 // MEX文件接口函数
 ; ~2 ^6 Q7 S# L# T5 K' h7 I2 ~0 r( b1 b/ y: G4 p
 
2 b: a# D+ l* z: J/ p- I& W! S4 ~) E% S) Y! o. U  u7 f3 t
 void mexFunction(int nlhs,mxArray *plhs[], int nrhs,const mxArray *prhs[])' q' v8 z. z+ B6 z, }
 " O9 p( G$ \5 j! B
 
& G( R6 L4 ]7 v& y1 w, z) B
 - h+ W' f6 ~, z8 r+ h. S( W{2 ], e3 O, A1 j# c& j! V& [
 8 D9 c3 M1 z& O, `3 O* B7 K: U. i
 
, @+ y2 W% W$ @5 w/ M# }- f" T! [& Q/ [& x7 [( m
 double *z;2 u0 p- G3 v8 H1 g$ [+ A
 0 A& T" e* y4 K& f' \0 K
 
( b  W6 ?  H) D. H0 L( q7 X+ u' @9 ^! P9 I' E
 double x, y;6 y# |9 Y- u% S4 h. m
 
 ! H  |9 |6 U! U
: o: q7 V9 D- N2 _, w8 ?( B# D4 `! I
 plhs[0] = mxCreateDoubleMatrix(1, 1, mxREAL);
 q( m4 j* Q$ o; j9 W4 z3 z& @! N2 ^% O' \. d1 b1 V( ]
 
7 u6 b1 Q9 o" X3 }" O) A8 m" E
 8 ^% T' P, q+ e/ a    z = mxGetPr(plhs[0]);0 p& u+ Q) f' u/ O, ]( M, \: @6 d
 8 u# k% i' L, V
 
- t. c; W$ n, k4 U0 F
 7 l( H, a8 L- J# o3 j    x = mxGetScalar(prhs[0]));# ~3 v9 V. S( G% n, {% G
 8 H( w# u/ B1 m1 \+ s! v$ g
 
2 ~! |+ o( [7 I; l5 _( h4 p5 n* R6 {8 |. ]& h& A% Y
 y = mxGetScalar(prhs[1]));0 F" S6 `" s# Q7 u3 J, l2 n! Z
 4 F1 u+ w* g2 c, E) [/ j; E7 d
 
  }1 Y: z* v7 X6 A9 V  h) F1 ]; o6 j  F) {3 Q
 *z=x+y;7 s* F" |. J# E2 v6 |
 / e8 t, r! U  {- J4 u
 
4 J4 f3 l! \8 J. I. C8 S) N& g3 C/ m; }- i* l
 }
 0 `# `- F0 ~# y; B: S% h
 9 o! d) s9 e2 p( }: c/ l% }5 J9 V, }/ i0 Q$ x/ i7 ?
 
 (注意:输出参数因为需要通过指针传出,因此这里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) L/ _) v! K" v" f7 }
 #include "mex.h"' d0 ]% y- Y  \. P8 H6 E! g
 
 . L! M% I7 d5 j% Z' O
1 V- T$ I/ R0 \; t8 z1 |6 k0 p' x3 g# u% P" I+ w
 void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]){: [6 k( r1 K# W: l- H. P
 
 $ 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
7 A/ y) V/ x- T; c* W! O6 Y3 |6 W( T8 M7 K9 D: r
 double *data;8 D' E/ K: p8 s7 z3 i0 I
 ) e" f$ C) d- w% @5 {5 n5 R
 
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* L, M% E, a' @4 |
 
5 `: T! y* u; E5 L
 |9 ~% D. x) q2 [int i,j;7 }3 h0 B1 }! o) O/ Z4 s
 / K$ ?& m- X( m/ L1 `) m. w2 Y# S8 M
 
' ^# D( U) z* E$ Q, ?& D" [3 Y7 D2 Z2 U3 |1 A! D) V4 Z! l
 data=mxGetPr(prhs[0]); //获得指向矩阵的指针6 D6 C$ Z4 b. B* |, z1 T: `4 a1 U
 
 ( K  a2 i+ E: T, b* X. \+ x
/ ~7 {( `9 n& Q& J
 $ x" n' b1 O, _M=mxGetM(prhs[0]); //获得矩阵的行数
 5 }' T  d; S1 }) ~9 z
 9 O( I# Y) j. I8 |* i* P
* i1 G5 s$ ^+ v1 y: \) r% s8 n+ R# K/ P7 J
 N=mxGetN(prhs[0]); //获得矩阵的列数# m9 v+ V$ ^2 v- }
 + h0 [; v! H1 Q1 o* I
 
3 g( d& t# k. F  c8 |) D8 ]/ v) @
 for(i=0;i<M;i++)- h4 l# }* M0 B- \3 U6 i9 ]; H
 
 ) \& 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" ?! H3 C( U. f+ ^, y! c! f
 
3 E; d- U8 y% o
 / k) l( H' Z0 m5 c) b   for(j=0;j<N;j++)( i1 k6 w" x8 u
 " p9 U# \" H) i- L$ m/ h* l
 
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
5 h( }! h* @% G$ K- K8 C' n/ r1 X) A  B
 mexPrintf("\n");
 3 L0 ?6 X( L) T) Z9 V4 V
 ! l" R3 J7 m" t+ E  e$ S8 J9 g0 C
) ^* h) G" n& u& [, \. p& N- O
 + C  i2 x+ h  _5 U6 F6 _}
 / }: T$ G" H2 `$ ]$ Q+ S$ Z7 j/ b/ S2 f1 O1 l% }( M
 
7 [4 I" I6 Q# O7 k% ~) s3 F! a. O% o; @6 b, r. p0 {. a
 }8 ^: U, K0 g7 k+ _0 N& L; l
 
 * `- 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 , h5 m. d; w% U% ~
 - p/ G2 p' H6 {& U2 J! r9 R9 B4 i+ H# n/ I6 Z4 r+ K4 B
 
 & {; O5 N' Z. M& [' u
0 d% ]; K0 O4 p( F" }$ h1 z( o9 R2 g4 ]$ k  D9 u! h$ W
 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);% n) D, H( r, P) o6 U! N
 : a( J0 q& D- X7 R4 R
 
) p2 W; w" V6 t' X
 ) H* {& M( L3 |: a' D$ R/ _) O    z = mxGetPr(plhs[0]);6 I: s2 `  y( c9 C6 ~
 
 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 |
6 R5 K! a. v: U5 p+ C9 n1 U& b  o$ h
 y = *(mxGetPr(prhs[1]));
 3 k3 z9 U) W5 B: \8 s6 C* I& z; B' h" `
 
- N9 \5 C) D* @. Q. \; C
 & h7 @6 l" Z1 o  N6 ]. c    *z=x+y;
 o+ n* c# {+ F1 a1 J- ]2 G( s. U
 
 + m4 {+ V) k) D6 `2 \* \
 当然,matlab里使用到的并不只是double类型这一种矩阵,还有字符串类型,结构类型矩阵等,并也提供了对应的处理函数。 1 N5 x& t( N; X7 A& C
 |