c语言typedef关键字的理解

 

1.typedef的定义

  很多人认为typedef 是定义新的数据类型,这可能与这个关键字有关。本来嘛,type 是数据类型的意思;def(ine)是定义的意思,合起来就是定义数据类型啦。

  不过很遗憾,这种理解是不正确的。也许这个关键字该被替换为“typerename”或是别的词。

1
typedef 的真正意思是给一个已经存在的数据类型(注意:是类型不是变量)取一个别名,而非定义一个新的数据类型。 

 

  在实际项目中,为了方便,可能很多数据类型(尤其是结构体之类的自定义数据类型)需要我们重新取一个适用实际情况的别名。这时候typedef 就可以帮助我们。

例如:

1
2
3
4
5
6
typedef struct student
{
//code
}Stu_st,*Stu_pst;
A)struct student stu1;和Stu_st stu1;没有区别。
B)struct student *stu2;和Stu_pst stu2;和Stu_st *stu2;没有区别。

  这个地方很多初学者迷惑,B)的两个定义为什么相等呢?其实很好理解。

  我们把“struct student { /*code*/}”看成一个整体,typedef 就是给“struct student {/*code*/}”取了个别名叫“Stu_st”;同时给“struct student { /*code*/} *”取了个别名叫“Stu_pst”。

  不管在C还是C++代码中,typedef这个词都不少见,当然出现频率较高的还是在C代码中。typedef与#define有些相似,但更多的是不同,特别是在一些复杂的用法上,就完全不同了,看了网上一些C/C++的学习者的博客,其中有一篇关于typedef的总结还是很不错,由于总结的很好,我就不加修改的引用过来了。

 

用途一:

 

定义一种类型的别名,而不只是简单的宏替换。可以用作同时声明指针型的多个对象。比如:

1
char* pa, pb; // 这多数不符合我们的意图,它只声明了一个指向字符变量的指针,和一个字符变量;

以下则可行:

1
2
3
typedef char* PCHAR;
 
PCHAR pa, pb; 

这种用法很有用,特别是char* pa, pb的定义,初学者往往认为是定义了两个字符型指针,其实不是,而用typedef char* PCHAR就不会出现这样的问题,减少了错误的发生。

 

用途二:

 

用在旧的C代码中,帮助定义结构体struct。以前的代码中,声明struct新对象时,必须要带上struct,即形式为: struct 结构名对象名,如:

1
2
3
4
5
6
7
struct tagPOINT1
{
int x;
int y;
};
 
struct tagPOINT1 p1;

而在C++中,则可以直接写:结构名对象名,即:tagPOINT1 p1;

1
2
3
4
5
6
7
typedef struct tagPOINT
{
int x;
int y;
}POINT;
 
POINT p1;

  

这样就比原来的方式少写了一个struct,比较省事,尤其在大量使用的时候,或许,在C++中,typedef的这种用途二不是很大,但是理解了它,对掌握以前的旧代码还是有帮助的,毕竟我们在项目中有可能会遇到较早些年代遗留下来的代码。

 

用途三:

 

用typedef来定义与平台无关的类型

比如:

1
2
3
4
5
6
定义一个叫 REAL 的浮点类型,在目标平台一上,让它表示最高精度的类型为:
typedef long double REAL;
在不支持 long double 的平台二上,改为:
typedef double REAL;
在连 double 都不支持的平台三上,改为:
typedef float REAL;

也就是说,当跨平台时,只要改下 typedef 本身就行,不用对其他源码做任何修改。

 

标准库就广泛使用了这个技巧,比如size_t。另外,因为typedef是定义了一种类型的新别名,不是简单的字符串替换,所以它比宏来得稳健。

这个优点在我们写代码的过程中可以减少不少代码量哦!

 

用途四:

 

这里其实不好理解,我一开始,就真的不大理解。有的地方,涉及到了函数指针的内容。

复杂的声明定义一个新的简单的别名。方法是:在原来的声明里逐步用别名替换一部分复杂声明,如此循环,把带变量名的部分留到最后替换,得到的就是原声明的最简化版。举例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
原声明:void (*b[10]) (void (*)());
 
变量名为b,先替换右边部分括号里的,pFunParam为别名一:
 
typedef void (*pFunParam)();
 
再替换左边的变量b,pFunx为别名二:
 
typedef void (*pFunx)(pFunParam);
 
原声明的最简化版:
 
pFunx b[10];
 
原声明:doube(*)() (*e)[9];
 
变量名为e,先替换左边部分,pFuny为别名一:
 
typedef double(*pFuny)();
 
再替换右边的变量e,pFunParamy为别名二
 
typedef pFuny (*pFunParamy)[9];
 
原声明的最简化版:
pFunParamy e;

  

理解复杂声明可用的“右左法则”:从变量名看起,先往右,再往左,碰到一个圆括号就调转阅读的方向;括号内分析完就跳出括号,还是按先右后左的顺序,如此循环,直到整个声明分析完。举例:

int (*func)(int *p);

首先找到变量名func,外面有一对圆括号,而且左边是一个*号,这说明func是一个指针;然后跳出这个圆括号,先看右边,又遇到圆括号,这说明(*func)是一个函数,所以func是一个指向这类函数的指针,即函数指针,这类函数具有int*类型的形参,返回值类型是int。

int (*func[5])(int *);

func右边是一个[ ]运算符,说明func是具有5个元素的数组;func的左边有一个*,说明func的元素是指针(注意这里的*不是修饰func,而是修饰func[5]的,原因是[]运算符优先级比*高,func先跟[]结合)。跳出这个括号,看右边,又遇到圆括号,说明func数组的元素是函数类型的指针,它指向的函数具有int*类型的形参,返回值类型为int。

这种用法是比较复杂的,出现的频率也不少,往往在看到这样的用法却不能理解,相信以上的解释能有所帮助。

下面还是举个例子吧,将来如果真的用到就算赚了O(∩_∩)O~

 

[html] view plaincopy
 
  1. #include<stdio.h>    
  2.     
  3. typedef int (*FP_CALC)(int, int);    
  4.   
  5. int add(int a, int b)    
  6. {    
  7.      return a + b;    
  8. }    
  9. int sub(int a, int b)    
  10. {    
  11.      return a - b;    
  12. }    
  13. int mul(int a, int b)    
  14. {    
  15.      return a * b;    
  16. }    
  17. int div(int a, int b)    
  18. {    
  19.      return b? a/b : -1;    
  20. }    
  21.   
  22. FP_CALC calc_func(char op)    
  23. {    
  24.      switch (op)    
  25.      {    
  26.      case ‘+‘: return add;//返回函数的地址    
  27.      case ‘-‘: return sub;    
  28.      case ‘*‘: return mul;    
  29.      case ‘/‘: return div;    
  30.      default:    
  31.          return NULL;    
  32.      }    
  33.      return NULL;    
  34. }    
  35.   
  36. int (*s_calc_func(char op)) (int, int)    
  37. {    
  38.      return calc_func(op);    
  39. }     
  40.   
  41. int calc(int a, int b, char op)    
  42. {    
  43.     FP_CALC fp = calc_func(op); //根据预算符得到各种运算的函数的地址  
  44.     //同样你也可以使用下面这种方法    
  45.     //int (*s_fp)(int, int) = s_calc_func(op);//用于测试    
  46.     //ASSERT(fp == s_fp);   // 可以断言这俩是相等的    
  47.     if (fp)   
  48.         return fp(a, b);    
  49.     else   
  50.         return -1;    
  51. }    
  52.     
  53. void main()    
  54. {       
  55.     int a = 100b = 20;    
  56.     printf("calc(%d, %d, %c) = %d\n", a, b, ‘+‘, calc(a, b, ‘+‘));    
  57.     printf("calc(%d, %d, %c) = %d\n", a, b, ‘-‘, calc(a, b, ‘-‘));    
  58.     printf("calc(%d, %d, %c) = %d\n", a, b, ‘*‘, calc(a, b, ‘*‘));    
  59.     printf("calc(%d, %d, %c) = %d\n", a, b, ‘/‘, calc(a, b, ‘/‘));    
  60. }    

结果

 

[html] view plaincopy
 
  1. calc(100, 20, +) = 120  
  2. calc(100, 20, -) = 80  
  3. calc(100, 20, *) = 2000  
  4. calc(100, 20, /) = 5  

想要具体了解的可以看看这段代码,相对理解起来简单很多

c语言typedef关键字的理解,布布扣,bubuko.com

c语言typedef关键字的理解

上一篇:K-Inversion Permutations 题解


下一篇:最简单的SLIC算法实现