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

编程喜欢用typedef,为什么?

[复制链接]
gaosmile 发布时间:2020-8-7 20:54
1. typedef 的基本使用
8 q2 l# l" M+ S  O3 z9 a  e
1.1 typedef与结构体的结合使用
typedef 是 C 语言的一个关键字,用来给某个类型起个别名,也就是给C语言中已经存在的一个类型起一个新名字。大家在阅读代码的过程中,会经常见到 typedef 与结构体、联合体、枚举、函数指针声明结合使用。比如下面结构体类型的声明和使用:

  1. * i2 D+ t8 i; e' t4 W2 Q6 n
  2. struct student
    0 Z' b7 c6 R: C5 O7 Z) M
  3. {7 }9 I! q8 L( h3 y6 @9 `
  4.   char name[20];- J) q8 N3 N- b' X2 N4 c0 h9 X
  5.   int  age;, \  j/ R& Z1 M0 g
  6.   float score;9 ]& Q# {3 v  L8 w! M  w
  7. };- m/ u; V8 a7 @+ \, ~
  8. struct student stu = {"wit", 20, 99};
复制代码
! h7 A/ E; _9 V8 d& A7 F
在C语言中定义一个结构体变量,我们通常的写法是:
  1. 3 t- g- d9 j; M, X' V4 f3 ?
  2. struct 结构体名 变量名;
复制代码

* g% B/ \& d3 Z( y3 C6 P) e
前面必须有一个struct关键字打前缀,编译器才会理解你要定义的对象是一个结构体变量。而在C++语言中,则不需要这么做,直接使用:结构体名 变量名就可以了
  1. 6 O+ I! }+ d5 a/ t# `9 u. g# Z
  2. struct student 6 I* S: \6 [! y4 A  D( n
  3. {
    ; t" Q5 a- f$ K7 B0 L% d, _, o. Y
  4.   char name[20];" b# \" J/ j3 ?8 j2 E0 ~
  5.   int age;
    3 i* U. Q# K7 W5 r2 C' y
  6.   float score; 7 u9 ?- r5 q; j/ ]. J
  7. };( H% q  `: |# T3 q5 h) O0 X7 Q- b
  8. int main (void), d5 e6 k, }- w- u
  9. {
    & x" j/ p* w6 `' u* X& W
  10.   student stu = {"wit", 20, 99};
    1 S: a, _1 P+ H' c) z9 p- S" x
  11.   return 0;
    . N$ Z1 w6 K" K+ G0 o. {
  12. }
复制代码

2 S: }" G. `  N; a
如果我们使用typedef,就可以给student声明一个别名student_t和一个结构体指针类型student_ptr,然后就可以直接使用student_t类型去定义一个结构体变量,不用再写struct,这样会显得代码更加简洁。
  1. 2 ?( F( X9 C; c/ i& S, b+ S" M
  2. #include <stdio.h>3 a  m6 Q( T, p; `
  3. typedef struct student
    # N. R/ m5 K* r
  4. {
    1 q- S! t& W4 O1 {
  5.   char name[20];$ Z& I2 A( K( K
  6.   int  age;% B" D" V4 V1 N+ t2 q) n
  7.   float score;
    ; l* t( e% B+ F; l
  8. }student_t, *student_ptr;
    0 [# h: V8 f& j" u& L/ u) t  W/ z$ B
  9.   }8 N' [, ~& V  E3 l- j4 Q& I* a
  10. int main (void)
    ! O7 m  `) Y' l  p5 d' n0 B
  11. {
    2 Z9 u5 w1 e; [7 U
  12.   student_t   stu = {"wit", 20, 99};
    + E; k1 z$ ~" q
  13.   student_t  *p1 = &stu;1 h8 W2 N* r- R' a& V
  14.   student_ptr p2 = &stu;
    ; Q2 `" z' A2 x' M* B8 n8 H/ j
  15.   printf ("name: %s\n", p1->name);
    : D% }4 x1 p& J" x
  16.   printf ("name: %s\n", p2->name);
      y# W/ d5 e- ?$ L9 V; v
  17.   return 0;
    ; R  V( [2 S( |% g! V" b  ^
  18. }) q/ o2 ], B& \# t6 z2 X  }) W5 A- t
  19. 程序运行结果:7 [- h" O1 w5 q- V4 e5 A
  20. wit
    % V7 e* l- J0 V$ N6 E1 y
  21. wit
    9 a, i7 R3 g1 Q* V1 E* g
复制代码
1. 2 typedef 与数组的结合使用
typedef除了与结构体结合使用外,还可以与数组结合使用。定义一个数组,通常我们使用int array[10];即可。我们也可以使用typedef先声明一个数组类型,然后再使用这个类型去定义一个数组。

  1. , ^, B9 z! o4 t  m1 u9 f
  2. typedef int array_t[10]; . f2 U' M* {3 N+ d: a4 q+ T2 \7 |
  3. array_t array;
    . z* l- X) Z/ M0 A
  4. int main (void)3 {2 g3 p) j" T- H( v% z2 p
  5. {# P9 `$ W& u9 @+ E# h* {- F4 [  J
  6.   array[9] = 100;
    % H) _" y2 M6 I+ M' {
  7.   printf ("array[9] = %d\n", array[9]);3 I$ w  o6 {/ J1 ?1 {( `$ k
  8.   return 0;! I, V' J  I9 \. @0 L. h, M0 d! [! Y
  9. }
复制代码
3 d+ l- t# |+ [; d- k
在上面的demo程序中,我们声明了一个数组类型array_t,然后再使用该类型定义一个数组array,这个array效果其实就相当于:int array[10]。

& L, c" F/ S+ X0 I$ }) v5 K4 ]
1.3 typedef 与指针的结合使用
5 q/ h5 j( U2 S* N% \
  1. <font face="Tahoma"><font size="3"><font color="black">2 [& f& w' W  s# C0 o' L4 U
  2. typedef char * PCHAR;
    + O$ Q9 N; k8 N0 K. ]4 R
  3. int main (void)
    ; ]' i$ x% P5 w/ N; {
  4. {
    $ [2 n) T& U7 h( L) N% S, P7 |
  5.     //char * str = "学嵌入式,到宅学部落";5 H4 W4 n& G' }
  6.   PCHAR str = "学嵌入式,到宅学部落";
    ( V0 P' N; ~! x! F$ U- `
  7.   printf ("str: %s\n", str);
    6 I# F/ O6 e4 h/ h1 Y
  8.   return 0;
    % S1 D7 q- }! A+ A+ J4 K4 d6 e4 g
  9. }</font></font></font>( L. K6 _7 s+ K6 g7 U/ M8 M
复制代码
5 S; f4 B2 M% p- j
在上面的demo程序中,PCHAR 的类型是 char *,我们使用PCHAR类型去定义一个变量str,其实就是一个char *类型的指针。
1.4 typedef与函数指针的结合使用
定义一个函数指针,我们通常采用下面的形式:
  1. / x( Q* v: w2 v
  2. int (*func)(int a, int b);
复制代码

/ [1 p4 A; U$ }& F- z) k
我们同样可以使用typedef声明一个函数指针类型:func_t

  1. : T. K1 q- X9 K. e9 g
  2. typedef int (*func_t)(int a, int b);) V1 z; U4 q7 f# L
  3. func_t fp;  // 定义一个函数指针变量
复制代码

' S7 e( G. u, r& R
写个简单的程序测试一下,运行OK:
  1. ; r. `: ~. ?8 o0 |' q6 E
  2. typedef int (*func_t)(int a, int b);
    ' l: c+ i' z. [$ O2 J5 i
  3. int sum (int a, int b)+ }/ i1 f- f9 \8 D3 k4 L
  4. {1 F# m# e3 u) K3 R, [' ]5 U
  5.   return a + b;- c: z# ]6 w0 a3 {+ W3 }+ [
  6. } + x, h) D% K" w  ]; B
  7. int main (void)
    . E( |4 }* t& U# `$ i
  8. {
    * h6 w7 p) P3 t8 {' q2 K- r
  9.   func_t fp = sum;
    4 U7 x+ Q9 w5 ?7 {) B, ]0 Y: _
  10.   printf ("%d\n", fp(1,2));9 ~5 W- ~8 ^, l& e: B( `( Y; K' A
  11.   return 0;  N( F/ R& ^9 J1 n
  12. }
复制代码

. Z/ d% s& k6 y; v
为了增加程序的可读性,我们经常在代码中看到下面的声明形式:
  1. $ M& J$ I" H: A" f& Y
  2. typedef int (func_t)(int a, int b);
    " i- g1 o# F; H2 M
  3. func_t *fp = sum;
复制代码
: v1 b9 F9 R0 V* J
函数都是有类型的,我们使用typedef给函数类型声明一个新名称:func_t。这样声明的好处是:即使你没有看到func_t的定义,也能够清楚地知道fp是一个函数指针,代码的可读性比上面的好。

- W; c2 U# I& [2 G0 K# c
1.5 typedef与枚举的结合使用  w3 ^- s* _+ n0 @! ]) Q

  1. . U3 c- m% q3 C/ z1 I
  2. typedef enum color
    , F& P* X: Q& v3 ^
  3. {
    6 m! w, }# n6 V& {( B% \
  4.   red,
    : ~8 T! y! C; H  @" m
  5.   white,
    . A& k% z- W( p7 e1 S0 W- S
  6.   black,) w+ p4 d9 n9 A8 i3 @
  7.   green,% P) Q" {( {, e: G0 r" @" n" y
  8.   color_num,
    + o0 p. M7 k& G- v2 Z6 c
  9. } color_t;$ N9 n* y& y6 u  M( E' b
  10. ; H2 x: k' b- d5 b/ m8 T7 z, ]/ ~: t) ?
  11. int main (void)
    2 W: K% S  b; J/ y
  12. {
    0 `3 F1 q- G" D2 o6 e1 `
  13.   enum color color1 = red;' k( K: }) r0 j/ }  [$ [% W7 d
  14.   color_t    color2 = red;! T. H/ [; V$ e  V+ q; A. J
  15.   color_t color_number = color_num;
    1 ]. F- t  K8 ]% X
  16.   printf ("color1: %d\n", color1);
    + M& a, ^0 G- s, u. u2 j( ]
  17.   printf ("color2: %d\n", color2);1 K& F6 E9 C6 ]/ w4 M
  18.   printf ("color num: %d\n", color_number);
    ; S6 I+ `: J+ \( R- _& a# W/ s
  19.   return 0;; h3 Z2 }$ N4 p+ g; _+ i8 o
  20. }
复制代码
* U$ p% h, c, y+ U9 M7 r/ K% a
* ^+ C4 R0 z6 \" N/ n( ^& t
枚举与typedef的结合使用方法跟结构体类似:可以使用typedef给枚举类型color声明一个新名称color_t,然后使用这个类型就可以直接定义一个枚举变量。

$ l+ G0 X* ?" t! N6 E
2. 使用typedef的优势
不同的项目,有不同的代码风格,也有不同的代码“癖好”。看得代码多了,你会发现:有的代码喜欢用宏,有的代码喜欢使用typedef。那么,使用typedef到底有哪些好处呢?为什么很多人喜欢用它呢?
2.1 可以让代码更加清晰简洁2 Y2 V( F+ @! ]: F& b( y

  1. . N$ U/ i, {. o7 d( P) Q6 B
  2. typedef struct student0 V' T5 ]! E4 i. D- \8 p
  3. {
    9 N  l9 |+ z3 G1 [) K
  4.   char name[20];
    / |/ S6 K4 x% l  L6 i. b
  5.   int  age;; D& i  o5 K' G, J
  6.   float score;3 M( l+ }. b. I9 F
  7. }student_t, *student_ptr;3 Q+ e. B! n& `5 \
  8.   m. b. N0 L) ^1 m# W. r
  9. student_t   stu = {"wit", 20, 99};
    3 q% m4 d$ ]# Y
  10. student_t  *p1 = &stu;- s! e! q3 W5 w' Y/ b/ X/ ^
  11. student_ptr p2 = &stu;0 v7 s$ C# k, d9 w& p, ^
复制代码

% Q! m5 G5 q# F- l9 C
如示例代码所示,使用typedef,我们可以在定义一个结构体、联合、枚举变量时,省去关键字struct,让代码更加简洁。
2.2 增加代码的可移植性
C语言的int类型,我们知道,在不同的编译器和平台下,所分配的存储字长不一样:可能是2个字节,可能是4个字节,也有可能是8个字节。如果我们在代码中想定义一个固定长度的数据类型,此时使用int,在不同的平台环境下运行可能会出现问题。为了应付各种不同“脾气”的编译器,最好的办法就是使用自定义数据类型,而不是使用C语言的内置类型。

  1. 1 d: u9 @1 a  M( s
  2. #ifdef PIC_16( g8 d. ~  _# D4 i2 X2 T9 O0 L
  3. typedef  unsigned long U32
    % W# F; s% q- U2 o" @
  4. #else
    . A2 f. L' S; o6 G2 i% {* c. f
  5. typedef unsigned int U32  
    3 W% v2 Z6 H0 `& e
  6. #endif
复制代码

. v0 F& v8 \, Z
在16位的 PIC 单片机中,int一般占2个字节,long占4个字节,而在32位的ARM环境下,int和long一般都是占4个字节。如果我们在代码中想使用一个32位的固定长度的无符号类型,可以使用上面方式声明一个U32的数据类型,在代码中你可以放心大胆地使用U32。将代码移植到不同的平台时,直接修改这个声明就可以了。
在Linux内核、驱动、BSP 等跟底层架构平台密切相关的源码中,我们会经常看到这样的数据类型,如size_t、U8、U16、U32。在一些网络协议、网卡驱动等对字节宽度、大小端比较关注的地方,也会经常看到typedef使用得很频繁。
2.3 比宏定义更好用
C语言的预处理指令#define用来定义一个宏,而typedef则用来声明一种类型的别名。typedef跟宏相比,不仅仅是简单的字符串替换,可以使用该类型同时定义多个同类型对象。
  1. 6 a6 L# r( @( E
  2. typedef char* PCHAR1;- v! j, @) I% G, b# I2 b4 @
  3. #define PCHAR2 char *
    ! J- B/ g+ u3 z5 I. {' s

  4. : f% x& \/ W" j9 s3 F$ L" W
  5. int main (void)
    / G1 v. {# O( x: K, c
  6. {
    2 j$ z% S3 K, k" d' j
  7.   PCHAR1 pch1, pch2;3 R2 x$ Z( [  ^) n" d' f1 p
  8.   PCHAR2 pch3, pch4;
    $ ]4 `0 o( |$ w' I
  9.   printf ("sizeof pch1: %d\n", sizeof(pch1));
    1 p6 x- a. s; c& o: e9 @
  10.   printf ("sizeof pch2: %d\n", sizeof(pch2));
    " Y4 [* Y2 f$ b$ G6 {- H
  11.   printf ("sizeof pch3: %d\n", sizeof(pch3));5 ]# V' b1 o+ K# c# L% F
  12.   printf ("sizeof pch4: %d\n", sizeof(pch4));
    ( R1 F# r+ E! d+ F) ]- J2 X
  13.   return 0;
    6 T2 `, ^( N, A) A3 O- ~) z& v& ?
  14. }
复制代码

. |6 ^- E0 T/ b! K1 S
在上面的示例代码中,我们想定义4个指向char类型的指针变量,然而运行结果却是:

  1. 4 v* O' f" n) s  {0 k( K9 U
  2. sizeof pch1: 4
    5 E$ q% o( t) {' {; ^$ |
  3. sizeof pch2: 41 i; J5 d; ^9 q$ F+ C3 N3 O! l
  4. sizeof pch3: 4; {: x8 _; N; b/ P$ _* S
  5. sizeof pch4: 1
复制代码
8 S, s& e! ~9 E" u
本来我们想定义4个指向char类型的指针,但是 pch4 经过预处理宏展开后,就变成成了一个字符型变量,而不是一个指针变量。而 PCHAR1 作为一种数据类型,在语法上其实就等价于相同类型的类型说明符关键字,因此可以在一行代码中同时定义多个变量。上面的代码其实就等价于:
  1. 8 x! Q( a; M% k8 K  ^# o) {) C
  2. char *pch1, *pch2;
    : g# X4 ?+ E& X3 E
  3. char *pch3, pch4;
    6 ?; j: M5 b4 l* o& ]8 N% Y4 @
复制代码
2.4 让复杂的指针声明更加简洁
一些复杂的指针声明,如:函数指针、数组指针、指针数组的声明,往往很复杂,可读性差。比如下面函数指针数组的定义:
  1. : J) O' q1 G6 J3 y+ @. u
  2. int *(*array[10])(int *p, int len, char name[]);
复制代码
- g" Q% _% J. n* n1 ?
上面的指针数组定义,很多人一瞅估计就懵逼了。我们可以使用typedef优化一下:先声明一个函数指针类型func_ptr_t,接着再定义一个数组,就会更加清晰简洁,可读性就增加了不少:
  1. % s6 x. G) a; @+ r0 l- T8 j3 W. L8 F9 y
  2. typedef int *(*func_ptr_t)(int *p, int len, char name[]);
    2 X0 j+ s/ t" m" Q5 V2 z
  3. func_ptr_t array[10];/ W. K) @. n: [* u6 R& y! h  e# p4 v
复制代码
3. 使用typedef需要注意的地方
通过上面的示例代码,我们可以看到,使用typedef可以让我们的代码更加简洁、可读性更强一些。但是typedef也有很多坑,稍微不注意就可能翻车。下面分享一些使用typedef需要注意的一些细节。
3.1 typedef在语法上等价于关键字
我们使用typedef给已知的类型声明一个别名,其在语法上其实就等价于该类型的类型说明符关键字,而不是像宏一样,仅仅是简单的字符串替换。举一个例子大家就明白了,比如const和类型的混合使用:当const和常见的类型(如:int、char) 一同修饰一个变量时,const和类型的位置可以互换。但是如果类型为指针,则const和指针类型不能互换,否则其修饰的变量类型就发生了变化,如常见的指针常量和常量指针:
  1.   ?9 `) o' N% Q4 Z
  2. char b = 10;
    ! @! R# W; s: @( s) s) ^( M; W4 N
  3. char c = 20;
    ' p' E' P0 _/ m' U% Y
  4. int main (void)
    ' M) [! @1 @- w- |
  5. {  
    0 R( u4 ^/ K  F# Y
  6.   char const *p1 = &b; //常量指针:*p1不可变,p1可变' b3 u& }! p9 s* k6 ~3 v  L
  7.   char *const p2 = &b; //指针常量:*p2可变,p2不可变  
    - Q8 [" m8 c8 O# |5 s# w9 b! A
  8.   p1  = &c; //编译正常 * m- r, j7 v3 }) B3 v6 e* h
  9.   *p1 = 20; //error: assignment of read-only location  . z) X; [( h+ N9 K
  10.   p2  = &c; //error: assignment of read-only variable`p2'
    2 k! `) _: Q4 u: w
  11.   *p2 = 20; //编译正常: Z8 s; l. ~9 @+ |2 H( J
  12.   return 0;
    # |% V$ \% X# M3 y: H
  13. }
复制代码
( M( s( q# [/ N- f& m- i% X; O
当typedef 和 const一起去修饰一个指针类型时,与宏定义的指针类型进行比较:
  1. 1 Z: `3 j1 d7 \/ W0 J$ `
  2. typedef char* PCHAR2;* d; e" ^. g8 o" r1 z9 b" Q
  3. #define PCHAR1 char *
    4 H& M1 t, D% G6 Z) v! x6 C
  4. char b = 10;
    ) ]1 {& _% E" E
  5. char c = 20;  E3 V$ k4 c8 ]
  6. int main (void), i1 h; [) l" M! k/ z* `
  7. {  5 i% ]+ r/ l7 Q: }. o
  8.   const PCHAR1 p1 = &b;% f6 P% y- O. C2 v
  9.   const PCHAR2 p2 = &b;
    " e; a" D$ f& d: p# g
  10.   p1  = &c; //编译正常 - F! a+ N. r) {' W! T+ E# u! D  m
  11.   *p1 = 20; //error: assignment of read-only location  
    7 W- r% Z9 H# _7 o: V$ P
  12.   p2  = &c; //error: assignment of read-only variable`p2'
    + h" R' |+ N" S3 l
  13.   *p2 = 20; //编译正常- m* j* z6 p6 H1 v, x
  14.   return 0;
    , O& Q# e! y4 v' R; [6 x
  15. }
复制代码

5 Q. Y7 G8 S1 o0 [: b
运行程序,你会发现跟上面的示例代码遇到相同的编译错误,原因在于宏展开仅仅是简单的字符串替换:
  1.   R. _, D# ^# I/ N  b, S; T) A
  2. const PCHAR1 p1 = &b; //宏展开后是一个常量指针% Z7 w( v& X1 k$ k/ m
  3. const char * p1 = &b; //其中const与类型char的位置可以互换
复制代码
0 _) m" Q; }$ n  q8 Q, w1 }" Q& D. J
而在使用PCHAR2定义的变量p2中,PCHAR2作为一个类型,位置可与const互换,const修饰的是指针变量p2的值,p2的值不能改变,是一个指针常量,但是*p2的值可以改变。
  1. " ]4 u" G, F& J
  2. const PCHAR2 p2 = &b; //PCHAR2此时作为一个类型,与const可互换位置
    " T! r2 L8 {) o3 j7 M/ X$ }) P' _2 g
  3. PCHAR2 const p2 = &b; //该语句等价于上条语句# y3 @) u9 ^+ M1 j* C0 H
  4. char * const p2 = &b; //const和PCHAR2一同修饰变量p2,const修饰的是p2!
复制代码

0 y8 Y( E, `# I: _# D; B0 }8 Y
3.2 typedef是一个存储类关键字
没想到吧,typedef在语法上是一个存储类关键字!跟常见的存储类关键字(如:auto、register、static、extern)一样,在修饰一个变量时,不能同时使用一个以上的存储类关键字,否则编译会报错:

  1. 6 C3 N. }, q! L( q7 [. `
  2. typedef static char * PCHAR;
    ( Y% k: W. D: E# v$ t$ i; t3 _
  3. //error: multiple storage classes in declaration of `PCHAR'1 k$ j1 N- G1 ?7 X, |- ~( a
复制代码
3.3 typedef 的作用域
跟宏的全局性相比,typedef作为一个存储类关键字,是有作用域的。使用typedef声明的类型跟普通变量一样遵循作用域规则:包括代码块作用域、文件作用域等。
  1. * C2 W: _: D4 u7 z7 f
  2. typedef char CHAR;
    . v+ a: c  O8 d6 V5 A8 k5 b

  3. , s# A4 u0 n# E% ]5 Y1 T4 P* d1 B
  4. void func (void)% |# J7 h7 z# m/ L- |8 D! O9 G( g( j
  5. {! @  L& b5 x, e" h; Y& P
  6.   #define PI 3.14
    ( t9 o9 X& B  F; `! o8 X* m
  7.   typedef short CHAR;) H4 W! `9 Y$ ^* J
  8.   printf("sizeof CHAR in func: %d\n",sizeof(CHAR));
    : t- Z) J) ~  P9 X, Q5 E3 T9 b4 U
  9. }
    & y- d* p) T7 e% {- G* ~
  10. ) N' q8 T" h* c: _
  11. int main (void)
    - q" L* d, s4 g% F
  12. {  
    9 x& z8 z7 ~6 K$ F! b# f
  13.   printf("sizeof CHAR in main: %d\n",sizeof(CHAR));
    ' P- Q' D+ D- z
  14.   func();
    # |0 S  S' x; a- ?7 {0 k
  15.   typedef int CHAR;1 v" k$ N8 ?  _3 ]! T& [
  16.   printf("sizeof CHAR in main: %d\n",sizeof(CHAR));
    4 ^2 H1 L& W5 n0 @3 ~" N' F
  17.   printf("PI:%f\n", PI);  % g, s+ i) G, }1 {$ X, @7 E1 a3 K( a
  18.   return 0;
    0 @# B  T$ l, I; Q
  19. }
复制代码
' i4 P; z( }" v7 R" N0 c% I! R9 H
宏定义在预处理阶段就已经替换完毕,是全局性的,只要保证引用它的地方在定义之后就可以了。而使用typedef声明的类型则跟普通变量一样遵循作用域规则。上面代码的运行结果为:

  1. # [8 j9 V4 w& _& l" U7 ^7 L4 q9 ?
  2. sizeof CHAR in main: 1
    $ l* C$ E% ^1 H% `
  3. sizeof CHAR in func: 2
    0 t, Z$ z9 g! S' w+ }" X3 H
  4. sizeof CHAR in main: 4
    0 {. g6 L: P" }# v: P/ g
  5. PI:3.140000* m( N' e8 C  w  [, h
复制代码

" E2 l* \, R, a
4 如何避免typedef的滥用?
通过上面的学习我们可以看到:使用typedef可以让我们的代码更加简洁、可读性更好。在实际的编程中,越来越多的人也开始尝试使用typedef,甚至到了“过犹不及”的滥用地步:但凡遇到结构体、联合、枚举都要用个typedef封装一下,不用就显得你low、你菜、你的代码没水平。
其实typedef也有副作用,不一定非得处处都用它。比如上面我们封装的STUDENT类型,当你定义一个变量时:

  1. 5 t! M9 a! y7 d9 I+ z
  2. STUDENT stu;
    . o% t" t; [" V4 L( _- g
复制代码
不看STUDENT的声明,你知道stu的含义吗?未必吧。而如果我们直接使用struct定义一个变量,则会更加清晰,让你一下子就知道stu是个结构体类型的变量:

  1. , j- N5 R$ K4 _! k0 a
  2. struct  student stu;
    1 |* {9 W+ C4 d# O* s+ J9 H
复制代码
一般来讲,当遇到以下情形时,使用typedef可能会有用,否则可能会适得其反:
  • 创建一个新的数据类型
  • 跨平台、指定长度的类型:如U32/U16/U8
  • 跟操作系统、BSP、网络字宽相关的数据类型:如size_t、pid_t等
  • 不透明的数据类型:需要隐藏结构体细节,只能通过函数接口访问的数据类型
    2 E) X6 M+ p3 p, w# K& V
在阅读Linux内核源码过程中,你会发现大量使用了typedef,哪怕是简单的int、long都使用了typedef。这是因为:Linux内核源码发展到今天,已经支持了太多的平台和CPU架构,为了保证数据的跨平台性和可移植性,所以很多时候不得已使用了typedef,对一些数据指定固定长度:如U8/U16/U32等。但是内核也不是到处到滥用,什么时候该用,什么不该用,也是有一定的规则要遵循的,具体大家可以看kernel Document中的 CodingStyle 中关于typedef的使用建议。

" d) ^6 }6 L& F5 I1 S, {2 v
赞 收藏 1 评论0 发布时间:2020-8-7 20:54

举报

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