c语言中typeof关键字

c语言中typeof关键字
下面这两个等效声明,用于声明int类弄的变量a
typeof(int) a;
typeof('b') a; //
相当于获取'b'的类型,定义一个变量a

下面用于声明指针和数组
typeof(int*) p1,p2;
typeof(p1) p2  //p1
p2的类型一致
int *p1,*p2;

typeof(int [10]) a1,a2;
int a1[10],a2[10];

如果将typeof用于表达式,则该表达式不会执行,只会得到表达式的类型,以下示例声明了int类型的var变量,因为表达式foo()int类型的,由于表达式不会被执行,所以不用调用foo()函数

char *str1 = "123";
int my_atoi(const char *str)
typeof( my_atoi(str2)) sum = 100;   //
相当于等同去int sum;
typeof( my_atoi()) sum = 100;  //
错误用法,函数有参数则必须带入实参

使用typeof的声明限制
typeof构造中的类型名不能包含存储类说明符,
externstatic.不过允许包含类型限定符,
constvolatile.例如,下列代码是无效的.因为它在typeof构造中声明了extern;
typeof(extern int) a;

下列代码使用外部链接来声明标识符b是有效的,表示一个int类型的对象.下一个声明也是有效的,它声明了一个使用const限定符的char类型指针,表示指针p不能被修改.

char *str1 = "123";
extern typeof(int) b;
typeof(char*const) p=str1;//
常指针,不能修改指针指向;常量const类型必须在声明的时候就初始化
在宏声明中使用typeof

typeof
构造的主要应用是用在宏定义中。可以使用typeof关键字来引用宏参数的类型。

 

 

 

另一篇博客:http://blog.csdn.net/zhanshen2015/article/details/51495273

如果你是 C++ 程序员,应该接触过 C++11 里的 decltype 操作符,它的作用是自动推导表达式的数据类型,以解决泛型编程中有些类型由模板参数决定而难以(甚至不可能)表示的问题。其实这个特性在 C 语言中也早有类似的实现,GNU C 标准中的一个扩展特性 typeof (PS: 不是 typedef)作用与 decltype 类似,我们来看看这个关键字该怎么用。


先来看一个最简单的例子:

  1. // demo 01  
  2. int var = 666;  
  3. typeof(int *) pvar = &var;  
  4. printf("pvar:\t%p\n", pvar);  
  5. printf("&var:\t%p\n", &var);  
  6. printf("var:\t%d\n", var);  
  7. printf("*pvar:\t%d\n", *pvar);  
// demo 01
int var = 666;
typeof(int *) pvar = &var;
printf("pvar:\t%p\n", pvar);
printf("&var:\t%p\n", &var);
printf("var:\t%d\n", var);
printf("*pvar:\t%d\n", *pvar);


我们先定义了一个 int 型变量 var,然后再定义一个指针型变量指向 var,一般我们就直接 int *xxx = &xx,但是我们为了演示 typeof 的用法,就不要这么直接了,typeof 是自动推导后面 ( ) 里的数据类型,所以 typeof(int *) 直接推导出了 int * 型,用这个类型声明了 pvar 并将其初始化为 var 的地址,输出结果应该就显而易见了,这是在我的机器上的输出:


好吧我承认上面那个例子是吃力不讨好,明明写个 int * 简单又明了,非得加个 typeof 搞得这么晦涩,其实 typeof 的功效在于其能够自动推导表达式类型,比如我们把刚才的 typeof(int *) 改成 typeof(&var),它也会自动推导出 &var 的类型 —— int * 型,你可以自己试一下,原理是一样的,这样的话,当遇到一个非常复杂的表达式我们很难推断其类型的时候,typeof 就很有用了。另外有一点要注意:typeof  是 GNU C 标准里特有的扩展,标准的 ISO C 并没有这个关键字,所以在编译的时候不能加任何 ISO 的 C 标准选项,否则会报错,比如编译上面的代码我加入了一个 -std=c90 的选项,编译器就会有提示一堆 error:


解决的方法很简单,把 -std=c90 改成 -std=gnu90 即 GNU 的标准即可。


再来几个例子,比如

  1. // demo 02  
  2. int *pvar = NULL;  
  3. typeof(*pvar) var = 999;  
  4. printf("var:\t%d\n", var);  
// demo 02
int *pvar = NULL;
typeof(*pvar) var = 999;
printf("var:\t%d\n", var);


这个例子是先定义了一个整型指针变量 pvar,typeof 后面括号里的表达式为*pvar,pvar 的类型为 int * 型,那 *pvar 当然就被解析为 int 型,所以用这个类型声明的变量 var 也是 int 型,就相当于 int var = 999; 输出结果如下:


再来:

  1. // demo 03  
  2. int *pvar = NULL;  
  3. typeof(*pvar) var[4] = {11, 22, 33, 44};  
  4. for (int i = 0; i < 4; i++)  
  5.     printf("var[%d]:\t%d\n", i, var[i]);  
// demo 03
int *pvar = NULL;
typeof(*pvar) var[4] = {11, 22, 33, 44};
for (int i = 0; i < 4; i++)
	printf("var[%d]:\t%d\n", i, var[i]);

这次 typeof 解析出来的类型跟上一个一样,区别是 var 是一个包含四个元素的数组,相当于 int var[4] = {...}; 输出如下:



这次来个有点水平的:

  1. // demo 04  
  2. typeof(typeof(const char *)[4]) pchar = {"hello""world""good""night"};  
  3. for (int i = 0; i < 4; i++)  
  4.     printf("pchar[%d]:\t%s\n", i, pchar[i]);  
// demo 04
typeof(typeof(const char *)[4]) pchar = {"hello", "world", "good", "night"};
for (int i = 0; i < 4; i++)
	printf("pchar[%d]:\t%s\n", i, pchar[i]);


这次看起来就比较复杂了,考验你指针功底的时候到了,他嵌套了两层 typeof,我们一层一层的往外剥,先看最里层,typeof 先解析出一个 const char * 类型,有经验的 C 程序员应该马上就能联想到字符串了吧,而后面又跟着一个 [4],说明这是一个包含四个字符串的数组类型,那么这个类型也就被最外层的 typeof 给解析到了,那么最终的 pchar 也就是这个类型了,相当于 const char *pchar[4] = {...}; 


再来考验一下你的指针,这次是函数指针:

  1. // demo 05  
  2. int add(int param1, int param2) {  
  3.     return param1 + param2;  
  4. }  
  5.   
  6. int sub(int param1, int param2) {  
  7.     return param1 - param2;  
  8. }  
  9.   
  10. int mul(int param1, int param2) {  
  11.     return param1 * param2;  
  12. }  
  13.   
  14. int main() {  
  15.     int (*func[3]) (intint) = {add, sub, mul};  
  16.     typeof(func[0](1, 1)) sum = 100;  
  17.     typeof(func[1](1, 1)) dif = 101;  
  18.     typeof(func[2](1, 1)) pro = 102;  
  19.   
  20.     printf("sum:\t%d\n", sum);  
  21.     printf("dif:\t%d\n", dif);  
  22.     printf("pro:\t%d\n", pro);  
  23.     return 0;  
  24. }  
// demo 05
int add(int param1, int param2) {
	return param1 + param2;
}

int sub(int param1, int param2) {
	return param1 - param2;
}

int mul(int param1, int param2) {
	return param1 * param2;
}

int main() {
	int (*func[3]) (int, int) = {add, sub, mul};
	typeof(func[0](1, 1)) sum = 100;
	typeof(func[1](1, 1)) dif = 101;
	typeof(func[2](1, 1)) pro = 102;

	printf("sum:\t%d\n", sum);
	printf("dif:\t%d\n", dif);
	printf("pro:\t%d\n", pro);
	return 0;
}


这个 demo 中先定义了三个函数,这三个函数都是返回值为 int 类型,并且接受两个 int 型的参数,然后在 main 函数中定义了一个函数指针数组 func,并用上面三个函数名将其初始化,然后我们来看底下的第一个 typeof  会推导出什么类型,func[0] 就是指 add 这个函数,后面的括号里跟了两个参数,说白了就是简单的 add(1, 1) 的调用,而 add 会返回一个 int 型值,所以最终推导出的类型就是 int 型,其它两个都是同理,所以 sum、dif、pro 其实就是三个整型数,相当于  int sum = 100; int dif = 101; int pro = 102; 好吧,我承认这个 demo 有点坑,而且这个例子举得不恰当,输出结果就是它们分别的值:


我们再看看它在宏定义中的应用:

  1. // demo 06  
  2. #define pointer(T)  typeof(T *)  
  3. #define array(T, N) typeof(T[N])  
  4.   
  5. int main() {  
  6.     array(pointer(char), 4) pchar = {"hello""world""good""night"};  
  7.     for (int i = 0; i < 4; i++)  
  8.         printf("pchar[%d]:\t%s\n", i, pchar[i]);  
  9.     return 0;  
  10. }  
// demo 06
#define pointer(T)  typeof(T *)
#define array(T, N) typeof(T[N])

int main() {
	array(pointer(char), 4) pchar = {"hello", "world", "good", "night"};
	for (int i = 0; i < 4; i++)
		printf("pchar[%d]:\t%s\n", i, pchar[i]);
	return 0;
}


这里用到了宏函数,pointer(T) 会被替换为 typeof(T *),也就是说 pointer 后面跟某个类型的名字,经过预处理之后就会变成用 typeof 解析相应类型的指针类型,而 array 后面跟一个类型名和一个整数,然后 typeof 就会解析为该类型的一个数组,这样 main 函数中的 array(pointer(char), 4),pointer(char) 首先会被解析为 char * 型,然后外层的 array 会再被解析为包含 4 个 char * 元素的数组类型,所以就相当于 char *pchar[4] = {...}; 输出结果如下:



好了,啰嗦了这么多,typeof 这个关键字总算是知道用来干什么了吧,感觉好像语法挺晦涩的,而且没有什么实际用途,那好吧,我再让大伙看一看实际项目中的一个例子:

  1. /* 
  2.  * 选自 linux-2.6.7 内核源码 
  3.  * filename: linux-2.6.7/include/linux/kernel.h 
  4.  */  
  5. #define min(x,y) ({ \  
  6.     typeof(x) _x = (x); \  
  7.     typeof(y) _y = (y); \  
  8.     (void) (&_x == &_y);        \  
  9.     _x < _y ? _x : _y; })  
/*
 * 选自 linux-2.6.7 内核源码
 * filename: linux-2.6.7/include/linux/kernel.h
 */
#define min(x,y) ({ \
	typeof(x) _x = (x);	\
	typeof(y) _y = (y);	\
	(void) (&_x == &_y);		\
	_x < _y ? _x : _y; })

上面这个例子是选自 linux 2.6.7 内核中 include/linux/kernel.h 这个头文件,宏定义 min 的作用是从两个相同类型的对象中选取一个最小的,它接受两个参数 x 和 y,后面的宏替换部分就用 typeof 定义两个变量 _x 和 _y,并分别赋值为 x y,这里用 typeof 的作用就是可以让 min 接受任何类型的参数而不必局限于某一个单一类型,这有点泛型编程的味道了,最后一个语句 _x < _y ? _x : _y; 用了一个条件运算符来返回二者之中最小的,中间还有一句 (void) (&_x == &_y); 看起来好像是废话,其实这句话是有特殊用意的,因为我们不能保证你在使用 min 的时候传入的两个参数都是相同的类型,这时候就需要做一个检测,而 C 语言不支持直接 typeof(_x) == typeof(_y) 这样的操作,所以就取其地址,用指针类型来比较,如果两个指针的类型不一致,编译器就会产生警告以达到检测的效果,至于前面的 (void),是因为仅表达式 &_x == &_y 本身是没有意义的,如果没有这个 (void) 编译器同样会警告:statement with no effect [-Wunused-value],无效的语句,如果不想看到这个警告,那就在前面加个 (void) 忽略掉。



参考资料:

GNU 官方手册:https://gcc.gnu.org/onlinedocs/gcc/Typeof.html

crifan 的个人网站:http://www.crifan.com/order_min__macro_definition_void_amp__x__amp__y_the_meaning_of/

 

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值