你的浏览器版本过低,可能导致网站不能正常访问!
为了你能正常使用网站功能,请使用这些浏览器。

几种函数宏的封装方式

[复制链接]
gaosmile 发布时间:2020-12-14 22:47
1、函数宏介绍函数宏,即包含多条语句的宏定义,其通常为某一被频繁调用的功能的语句封装,且不想通过函数方式封装来降低额外的弹栈压栈开销。函数宏本质上为宏,可以直接进行定义,例如:#define INT_SWAP(a,b) \
* r" x2 V; P- ?7 W. j! X    int tmp = a;    \
2 P5 e) \/ N1 r* _    a = b;          \
+ k5 K1 q! b8 J5 \: f    b = tmp
, M9 _, T7 |" F5 v, H
但上述的宏具有一个明显的缺点:当遇到 if、while 等语句且不使用花括号仅调用宏时,实际作用范围在宏的第一个分号后便结束。即 a = b 和 b = tmp 均不受控制语句所作用。因此,在工程中,一般使用三种方式来对函数宏进行封装,分别为{}、do{...}while(0) 和 ({})。下文将一一对三种方式进行分析,比较各自的优劣点。
& W; e; g- J3 T1 a8 z

" }# O9 O# A& \1 e2、{} 方式
INT_SWAP 宏使用 {} 封装后形态如下:
#define INT_SWAP(a,b)\* i* @# [6 O; ]; M3 ~
{                   \
5 Z! Z; N/ Q( S0 {# ^) U    int tmp = a;    \4 O& X3 i3 O$ v! h
    a = b;          \/ A, ]) y% K( U$ F8 m
    b = tmp;        \# o) N  F2 ~1 [+ P- d9 K0 U% }
}) L! ]& P" f9 E, Z6 w1 Q( C
此时,直接调用与在无花括号的控制语句(如 if、while)中调用均能正常运行,例如:
#define INT_SWAP(a,b) \
& G- X; V) ]. E6 q$ H. o# n{                   \
, k- @; v) c1 L    int tmp = a;    \
- ~7 S( h( w8 u  `  \! q8 K    a = b;          \
; H$ F; |5 f8 A' l# {    b = tmp;        \
! c# b, U7 S9 o9 O' p, s}
2 T7 Z: o$ {* V
0 B8 i& B) D; r/ [; j1 }int main()
$ W6 q. X5 |6 {5 g5 W" a{
+ c* H8 o5 O- R2 Y int var_a = 1;: Z# J& S+ }' k5 V* i! c
int var_b = 2;) K6 w9 P: l* y5 d6 u2 @
% o2 ?* w: q3 H" S; f$ G. d
INT_SWAP(var_a, var_b);
1 C: L- l0 Z6 ^6 ?/ _* G) T8 z printf("var_a = %d, var_b = %d\n", var_a, var_b);   // var_a = 2, var_b = 1
, q/ V- A; N2 ? $ x# c8 I$ B7 a& V8 `$ _! c
if (1)
6 b- c2 A, Y  `4 c4 B6 i" a    INT_SWAP(var_a, var_b);8 g8 a4 G% }/ V4 ?& |& C" \4 m5 ~
printf("var_a = %d, var_b = %d\n", var_a, var_b);   // var_a = 1, var_b = 2
/ f/ i5 o+ r; I( L}
2 y. g, X+ t; |9 _3 s
但当无花括号的 if 语句存在其他分支(else if、else 等)如:
if (1)4 L  u6 J# }4 Z" R5 C% X
   INT_SWAP(var_a, var_b);
, k. h# K( U$ U9 Relse3 W( h4 e$ a3 n+ J/ D
printf("hello world!\n");
/ m/ c+ W% S5 l; k
会发现编译出错:
...
6 g5 d$ O4 }' F* G1 }/mnt/hgfs/share/pr_c/src/main.c: In function ‘main’:5 l7 F. F  x1 u* M& d) ^
/mnt/hgfs/share/pr_c/src/main.c:18:2: error: ‘else’ without a previous ‘if’2 C/ W$ j! Y8 y5 ?8 f7 N* U+ G
  else  a; V. z3 }/ h: c2 [( q$ {. B: p
这是因为 INT_SWAP(var_a, var_b); 最后的 ; 已经把 if 的作用域终结了,后续的else 当然没有找到与之匹配的 if 了。因此,解决方法有两种,分别为不使用 ;(port.1)或规定必须使用带花括号的if(port.2),例如:/* port.1 */
/ z3 l7 B: T8 Oif (1)
3 C1 I! L9 W: T' A9 e3 l   INT_SWAP(var_a, var_b)" b% R: y. z% e& k
else
4 ~! h. N' c5 k{  G( E$ W+ ^: Y& X" T/ E! u! a
    printf("hello world!\n");# }0 j4 O1 S  E4 x
}
6 E# f4 M' b# Y6 d+ L9 T' D
( z1 ^8 j6 J" w, W- P/* port.2 */% z& s9 e9 `, }: x
if (1)) C( x% R# S! K4 ?' [
{  `2 u1 j1 V2 X. |0 O
   INT_SWAP(var_a, var_b);
; t( F0 ^8 T, b2 P}8 g1 Q2 g7 [( @& y0 Y. g
else
) o, K) ]" F( g, f7 O& j' e" e( h{6 p; K3 _0 O" K8 [6 \* a  T
    printf("hello world!\n");1 B; ~* x! H  ^
}
  z) V9 ]0 t6 V+ P9 o
可见,不使用 ; 的调用方式无论从程序阅读还是使用方法方面都是十分别扭的;而规定必须使用带花括号的 if 的调用方式有违常理的,因为宏函数应该适用于任何语法。
优缺点总结:
  • 优点:简单粗暴。
  • 缺点:不能在无花括号且有分支的 if 语句中直接调用;能够不带 ; 直接调用。7 G) Q5 ?6 K* i+ Z: a, k
3、do{…}while(0) 方式
INT_SWAP 宏使用 do{...}while(0) 封装后形态如下:
#define INT_SWAP(a,b)   \4 C& l  ?/ i3 M( x) \
do{                     \
$ V0 S8 b/ k4 @/ V$ V# S. {    int tmp = a;        \
+ u: W  X; X! a, _    a = b;              \9 H" u+ A8 R, h
    b = tmp;            \$ v3 Z4 k0 x, p+ h6 v2 G
}while(0)5 U# o3 ]# U  _7 h
do{...}while(0) 表示只执行一遍 {} 内的语句,表象来说与 {} 的功能是一致的。不同的是,do{...}while(0) 可以提前退出函数宏、整合为一条语句与强制调用时必须使用 ;。
由于 do{...}while(0) 实际为 while 循环,因此可以使用关键字 break 提前结束循环。利用该特性,可以为函数宏添加参数检测。例如:
#define INT_SWAP(a,b)  \
. u) l* O- O8 u4 {  E- Zdo{                 \& P; g0 p& {; e" ?
if (a < 0 || b < 0) \0 p- `/ U$ \4 n" a( X0 F
  break;   \
$ Q% E3 a$ g9 e% s2 W    int tmp = a;     \
9 a5 _2 A9 Q8 ?/ w2 H: X2 t  p* R    a = b;           \
2 Z+ b4 H8 Z8 K2 g    b = tmp;         \
9 ]: X, a9 D  S9 p}while(0); n9 h" w, V0 j
由于 do{...}while(0); 实际为一种语法,编译器会把 do{...}while(0); 认为为一条语句。
因此,do{...}while(0) 方式的函数宏可以在无花括号且有分支的 if 语句中直接调用。例如:
#define INT_SWAP(a,b)  \, E( W! f" B- n' \" n3 Q: z
do{                 \
, Z- K; d7 C% J1 W7 H if (a < 0 || b < 0) \. l' S  V! \9 O' s4 x* }
  break;   \! l8 ~  F6 G# g4 }2 a4 N
    int tmp = a;     \- Z+ q9 m+ ]0 h3 ^  ?4 J4 F0 d
    a = b;           \8 v+ b* l  {/ f- Z) G
    b = tmp;         \
( s& z) {0 p+ {/ r$ O, V" ]4 A}while(0)
# |8 ]& Q& S" Z7 R9 p6 {6 s1 C- j0 T+ d
int main()6 Z; i( R8 e5 v% r; n/ C
{
; v! w4 m9 ]0 X  D0 } int var_a = 1;5 g" \9 h4 H) [+ X9 o+ u
int var_b = 2;1 a, _8 J' R0 r$ L' s
; W: W' N# ]# f" Q
if (1)
, {) t7 k& L1 G8 g    INT_SWAP(var_a, var_b);
3 v0 `3 b5 v* Y else9 R2 I9 a+ E, X
  printf("hello world!\n"); & m/ E' Z9 T; ]' Q' x9 T2 \
printf("var_a = %d, var_b = %d\n", var_a, var_b); // var_a = 2, var_b = 1
" O& g) Z" H* U; D" f! A5 R& \  L8 |5 n( w  l! e# i8 c
return 0;
* D9 q  e3 N+ B" O4 q& X- a4 n4 k% t2 w}, g, {! A" |0 T! a0 A$ x- v
5 H  X8 F7 S& h% r- V* _7 q
C 语言规定,do{...}while(0) 语法必须使用 ; 作为语句结尾。因此不可能存在以下语句的程序出现:
if (1)
: I/ n& t" v" B; K& _   INT_SWAP(var_a, var_b)
& u( @* l# d1 T8 l+ C0 H# d1 s! Qelse
: j' f4 m8 N* y7 v+ T. t5 s{
- \5 H0 Z- k( B$ o- H  ~+ v printf("hello world!\n");
9 C, ^2 w  x' Q1 o* h}
6 `+ L3 ?: |1 m: y9 H+ |1 u' }# @' l
优缺点总结:
  • 优点:支持在无花括号且有分支的 if 语句中直接调用;支持提前退出函数宏;强制调用时必须使用 ;。
  • 缺点:无返回值,不能作为表达式的右值使用。
    ) b& [7 G9 w- h  s* ~
4、 ({}) 方式
({}) 为 GNU C 扩展的语法,非 C 语言的原生语法。
INT_SWAP 宏使用 ({}) 封装后形态如下:
#define INT_SWAP(a,b)   \7 h+ @# R2 `# n% Q0 ?3 f, }9 b* K
({                      \2 X7 d+ f: [9 R( C3 p; [- |" `
    int tmp = a;        \
$ L) ~# v9 Q. W7 u# |) J    a = b;              \8 c& u- v$ E  M" E
    b = tmp;            \4 x! ^% f; P+ g' n
})& G1 w+ e* z8 m  T& X
  C. g1 @4 q6 o: k6 w6 `7 J7 {  {
与 do{...}while(0) 相同,({}) 支持在无花括号且有分支的 if 语句中直接调用。例如:
#define INT_SWAP(a,b)  \
6 E/ R! u+ H. n" x+ \9 }+ L# E8 H({                 \3 e& h1 D1 N* q1 S! H
int tmp = a;    \
; g; U0 H' \$ K$ Z, V- {6 t a = b;          \
" O. y& \7 R5 t. p% X b = tmp;        \
$ x6 W4 l( v* l' j2 I})
! ^8 u+ _6 \* Y, T7 Z4 N' _  w, ~5 X) D$ h) n0 z& J# \- }* E1 m
int main()
# U; R# \" r: F  k& E{
3 F8 ]/ h* |2 Q0 d' f( f1 A int var_a = 1;
5 b  ]9 Q( m9 [+ E/ ^* @, [ int var_b = 2;
' x5 a; F! @) K+ e) Z5 u1 \" [3 [
+ s: v" |+ s5 q, Z if (1)1 f1 f# h, _9 O# b( ?# f
    INT_SWAP(var_a, var_b);
$ S3 z7 l. D1 M0 K9 z else. N# \& e7 x( Y0 u/ b
  printf("hello world!\n");
# l, e, h- M  m: a. c) { printf("var_a = %d, var_b = %d\n", var_a, var_b); // var_a = 2, var_b = 1& \% @# o! r3 L" Z& }$ @  A2 q- o

' K8 D& R# v3 L$ O return 0;. u* R4 q* _3 G2 j6 T
}% m5 S9 a! _# O! P& A6 B1 }6 |
5 W, X' e- R5 x( e+ o5 O$ A1 V) }
与 do{...}while(0) 不同的是,({}) 不能提前退出函数宏与支持返回值。({}) 毕竟不是 while 循环,不能直接使用 break退出函数宏是比较容易理解。那支持返回值是什么意思呢?
答案是 C 语言规定 ({}) 中的最后一条语句的结果为该双括号体的返回值。例如:
int main()
" ]6 T  H6 s9 @- C{3 ~7 R2 ?# c9 a# x. f
int a = ({3 }9 ?& q" A: D9 M3 e0 s6 U  }
  10;' H8 K8 f% T3 u" b& q) I
  1000;. P  g+ S$ }8 `" X: {- g9 i, g+ S5 q
});1 _. `( s$ O% R* I' ]( o1 M
printf("a = %d\n", a);      // a = 1000
' A0 M9 H8 |' z" F" i, b6 B/ y( Q}6 s: |; B. O% r7 X% {

$ }1 {: r& U0 ?; ?$ x
因此,({}) 可以为函数宏提供返回值。例如:
#define INT_SWAP(a,b)  \* i7 X2 u# ^7 @" A- e
({                 \0 z8 f$ j" |8 S  Z% y8 o
int ret = 0;  \
* W2 G$ h( ^2 o  N- M' a if (a < 0 || b < 0) \
* e, w8 z% l9 V5 x1 o. H- \0 t" \- v7 d {     \
# i+ ]9 t; R7 u- r4 E) f1 m( x  ret = -1;  \
, a: S7 y& r0 m( o7 J }     \! I- Z* E0 q+ G  M" E9 f/ f
else    \
0 o6 e- h& ~! H% C/ C5 y7 C' P/ |1 C {     \) m3 C$ _3 `- j# d8 h# ]
  int tmp = a;    \
; _; B/ `5 f' G; ~  a = b;          \1 H* T: C: Y7 H
  b = tmp;        \/ @% x# S% W5 z2 v8 p4 Q8 k
}     \/ w: g, [8 ~( q. D; f$ C
ret;    \
$ |) _' x6 d& j: {+ |* w, _1 |})2 z5 u3 t9 `1 Y3 u
0 K3 }# }7 d- O' O
int main()- V  Y! `6 B: ?+ j0 q4 U
{
  w  V8 g9 C( w% F1 c int var_a = 1;2 F; B  H! I& K  S0 P
int var_b = 2;, z& q2 O0 o+ h1 O+ O  B- i

( ~9 j$ v- g; s& _, f1 ~% o if (INT_SWAP(var_a, var_b) != -1)
* V* k4 J* c/ C: a  printf("swap success !!\n");     // swap success !!
. \7 C, h1 {( {# }/ |5 ? else( H* o, H2 M6 H. f, W) ?
  printf("swap fail !!\n");
0 N! C% m% Q0 k; q' y1 G printf("var_a = %d, var_b = %d\n", var_a, var_b); // var_a = 2, var_b = 1
" J, m8 m" ?. J  r
* B' P: s! V6 `5 } return 0;/ B& z* j4 v( S) Y3 R4 @
}
: l/ \! X. ?2 f* ^' L
可见,此时的 INT_SWAP 宏已与函数十分接近。
优缺点总结:
  • 优点:支持在无花括号且有分支的 if 语句中直接调用;有返回值,支持作为表达式的右值。
  • 缺点:不支持提前退出函数宏;非 C 的原生语法,编译器可能不支持。) o& M5 t+ i8 [0 g
5、 总结
综上,在 {}、do{...}while(0) 和 ({}) 这三种函数宏的封装方式之中,应尽可能不使用 {},考虑兼容性一般选择使用 do{...}while(0),当需要函数宏返回时可以考虑使用 ({}) 或直接定义函数。
4 f4 W8 w9 Y; Z+ V

5 I" H$ N* M) w$ R% g- i
1 N0 e7 ^" ?7 T! l
赞 收藏 评论0 发布时间:2020-12-14 22:47

举报

0个回答
关于
我们是谁
投资者关系
意法半导体可持续发展举措
创新与技术
意法半导体官网
联系我们
联系ST分支机构
寻找销售人员和分销渠道
社区
媒体中心
活动与培训
隐私策略
隐私策略
Cookies管理
行使您的权利
官方最新发布
人形机器人运动控制、感知与智能配电
半导体创新技术与应用方向
EE架构与软件定义汽车
12V/48V 汽车智能配电(SPD)
区域控制单元(ZCU)与分区架构
关注我们
st-img 微信公众号
st-img 手机版