Chinaunix首页 | 论坛 | 博客

河 的 第 三 条 岸shellway.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

shell_way

  • 博客访问： 67107
  • 博文数量： 7
  • 博客积分： 347
  • 博客等级： 二等列兵
  • 技术积分： 127
  • 用 户 组： 普通用户
  • 注册时间： 2011-01-26 17:18
个人简介

一句话介绍是什么？

文章分类

全部博文（7）

我的朋友
最近访客
推荐博文
相关博文
分析C语言的声明

分类： C/C++

2011-01-26 17:57:06

这是一篇针对于C语言新手的文章，能够让你轻松的阅读C语言那恐怖的声明形式。

-------------------------------------------------------------------------------------
C语言声明的阅读方法：
找到声明的标识符，然后按照优先级规则进行读取
        优先级：  1. 包含标识符的括号里的部分
                        2. 先看标识符（如果标识符包含在括号中则看括号）后面的后缀：
                                如果是小括号“()”则表示这是一个函数；
                                如果是方括号“[]”则表示这是一个数组。
                        3. 再看标识符（如果标识符包含在括号中则看括号）前面的前缀：
                                如果有星号“*”则表示这是一个指向……的指针。
注意：关键字const 和volatile 修饰的永远是它左边的东西，如果这两个关键字本身就在声明的最左边，那么它们就“只好”修饰右边的东西。
------------------------------------------------------------------------------------
现在让我们拿signal 函数的声明开个小刀 ;p
signal 的声明是：
  1. void (*signal(int signum,void (* handler)(int)))(int);
看起来有点惊心动魄？别怕，只要学会了上面的声明阅读方法再复杂的声明也轻松搞定 ;p

==================开始分析=================
找到声明的标识符signal，按照优先级规则读取。
先看包含标识符的括号里的部分：
        先看后缀，signal 后面有小括号“()”，表示signal 是一个函数，括号里是一些参数。于是声明简化为：
  1. void (*signal())(int);
        再看前缀，signal 的左边是星号“*”，表示signal 的返回值是一个指针。
看标识符所在括号外面的部分：
        先看后缀，后面是小括号“()”，则表示signal 返回的指针指向一个函数。
                看这个小括号里面是关键字int， 表示signal 返回的指针指向的函数有一个int 型参数。
        再看前缀，前面是关键字void ，则表示signal 返回的指针所指向的函数无返回值。
让我们把上面的分析综合起来：signal 是一个带参数的函数，返回一个指向以一个int 型变量做参数、无返回值的函数的指针。

好了，接着处理signal 的参数：
  1. int signum,void (* handler)(int)
先看第一个声明，找到标识符signum，只有一个用来修饰它的前缀int，则表示signum 是一个int 变量。
再看第二个声明，找到标识符 handler。
        首先看标识符所在括号里的部分，只有一个用来修饰它的前缀星号“*”，表示handler 是一个指针。
        再看标识符所在括号外面的后缀，发现小括号“()”，handler 指针指向一个函数。
                看这个小括号“()”里面的部分，发现有一个关键字int， 则表示这个函数接受一个int 型参数。
        接着看标识符所在括号外面的前缀，发现是关键字void，表示handler 指针指向的函数无返回值。
让我们把上面的分析综合起来：signum 是一个int 型变量，handler 是一个指向接受一个int 型参数、无返回值的函数的指针。
接着，我们把两部分的分析结果再做综合：
  1. void (*signal(int signum,void (* handler)(int)))(int);
的意思就是：signal 是一个函数。它的参数有两个：一个是int 型变量，另一个是一个函数指针，这个函数指针指向一个接受一个int 型参数、无返回值的函数。它的返回值是一个函数指针，指向的函数接受一个int 型参数、无返回值。
大功告成！
==================结束分析=================

下面给你个东西让你练练手 ;p
写一个函数指针，指向一个接受一个函数指针作为参数返回一个函数指针的函数。并用一个适当的main 函数版本来演示它的运行。

下面的代码是一种实现方法，不过你最好自己写完后再来看它 ;p
  1. /* * * * * * * * * * * * * * * * * * * * *
  2.  * pfunc是一个函数指针，指向一个接受
  3.  * 一个函数指针做参数并返回一个函数指针的函数
  4.  */

  6. #include <stdio.h>

  8. void (*func (void (*) (void))) (void);
  9. void func2 (void);

  11. int main
  12. (void) {
  13.         
  14.         void (*(*pfunc) (void (*) (void))) (void) = NULL;
  15.         void (*pfunc2) (void) = NULL;
  16.         void (*pfunc_tmp) (void) = NULL;
  17.         
  18.         pfunc2 = func2;
  19.         pfunc = func;
  20.         pfunc_tmp = *(*pfunc) (pfunc2);
  21.         (*pfunc_tmp) ();
  22.         puts ("Press ENTER to quit.\n");
  23.         getchar ();
  24.         
  25.         return 0;
  26. }

  28. void (*func (void (*pfunc) (void)))
  29. (void) {
  30.         puts ("Though func.\n");
  31.         (*pfunc) ();
  32.         
  33.         return pfunc;
  34. }

  36. void func2
  37. (void) {
  38.         
  39.         puts ("Though func2.\n");
  40.         
  41.         return;
  42. }
原本恐怖的C语言声明，现在看来是不是很简单呢 ？ ;p


---------------补充点东西------------------
下面是09年从c专抄的，99%纯手工抄，不过机器分析很爽
  1. /*
  2. cdecl程序，用于分析C语言的声明
  3. */

  5. #include <stdio.h>
  6. #include <ctype.h>
  7. #include <stdlib.h>
  8. #include <string.h>

  10. #define STRCMP(a, R, b) (strcmp(a, b) R 0)
  11. #define MAXTOKENS 100
  12. #define MAXTOKENLEN 64

  14. enum type_tag{ Identifer, Qualifier, Type };

  16. struct token
  17. {
  18.   char type;
  19.   char string[MAXTOKENLEN];
  20. };
  21. struct token stack[MAXTOKENS];
  22. struct token this;
  23. int top = -1;

  25. #define pop stack[top--]
  26. #define push(s) stack[++top] = s

  28. void Read_to_first_identifer(void);
  29. enum type_tag Classify_str(void); /*推断标识符的类型*/
  30. void Gettoken(void);/*读取下一个标记到this*/
  31. void Deal_with_declarator(void);
  32. void Deal_with_arrays(void);
  33. void Deal_with_function_args(void);
  34. void Deal_with_pointers(void);
  35. void Deal_wirh_declarator(void);


  38. int main(void)
  39. {
  40.   char next = 0;
  41.   printf("输入一个C语言声明,cdecl程序会把声明转化成通俗文字:\n");
  42.   do{
  43.     /*将标记压入堆栈，直至遇到标识符*/
  44.     Read_to_first_identifer();
  45.     Deal_with_declarator();
  46.     printf("\n是否进行下一个声明的推断(y\\n)?");
  47.   }while('Y' == toupper( next = getchar() ));
  48.   return 0;
  49. }

  51. void Read_to_first_identifer(void)
  52. {
  53.   Gettoken();
  54.   while(Identifer != this.type)
  55.   {
  56.     push(this);
  57.     Gettoken();
  58.   }
  59.   printf("%s is ", this.string);
  60.   Gettoken();
  61.   return;
  62. }

  64. void Gettoken(void)
  65. {
  66.   char *p = this.string;
  67.   
  68.   while( ' ' == (*p = getchar()) );/*忽略空格*/
  69.   
  70.   if(isalnum(*p))/*A~z,0~9*/
  71.   {
  72.     while(isalnum( *++p = getchar() ));
  73.     ungetc(*p, stdin);
  74.     *p = '\0';
  75.     this.type = Classify_str();
  76.     return;
  77.   }
  78.   
  79.   if('*' == *p)
  80.   {
  81.     strcpy(this.string, "pointer to");
  82.     this.type = '*';
  83.     return;
  84.   }
  85.   this.string[1] = '\0';
  86.   this.type = *p;
  87.   return;
  88. }

  90. enum type_tag Classify_str(void)
  91. {
  92.   char *s = this.string;
  93.   if(STRCMP(s, ==, "const")){ strcpy(s, "read-only"); return Qualifier; }
  94.   if(STRCMP(s, ==, "volatile")) return Qualifier;
  95.   if(STRCMP(s, ==, "void")) return Type;
  96.   if(STRCMP(s, ==, "char")) return Type;
  97.   if(STRCMP(s, ==, "int")) return Type;
  98.   if(STRCMP(s, ==, "long")) return Type;
  99.   if(STRCMP(s, ==, "float")) return Type;
  100.   if(STRCMP(s, ==, "double")) return Type;
  101.   if(STRCMP(s, ==, "signed")) return Type;
  102.   if(STRCMP(s, ==, "unsigned")) return Type;
  103.   if(STRCMP(s, ==, "struct")) return Type;
  104.   if(STRCMP(s, ==, "union")) return Type;
  105.   if(STRCMP(s, ==, "enum")) return Type;
  106.   return Identifer;
  107. }

  109. void Deal_with_declarator(void)
  110. {
  111.   /*处理标识符之后可能存在的函数或数组*/
  112.   switch(this.type)
  113.   {
  114.     case '[': Deal_with_arrays(); break;
  115.     case '(': Deal_with_function_args(); break;
  116.     default: break;
  117.   }
  118.   
  119.   Deal_with_pointers();
  120.   
  121.   /*处理在读入标识符之前压入堆栈的符号*/
  122.   while(-1 < top)
  123.   {
  124.     if('(' == stack[top].type)
  125.     {
  126.       pop;
  127.       Gettoken();
  128.       Deal_with_declarator();
  129.     }
  130.     else
  131.       printf("%s ", pop.string);
  132.   }
  133.   return;
  134. }

  136. void Deal_with_arrays(void)
  137. {
  138.   while('[' == this.type)
  139.   {
  140.     printf("array ");
  141.     Gettoken();/*数字或']'*/
  142.     if(isdigit(this.string[0]))
  143.     {
  144.       printf("0..%d ", atoi(this.string)-1);
  145.       Gettoken();/*读取']'*/
  146.     }
  147.     Gettoken();/*读取']'之后的再一个标记*/
  148.     printf("of ");
  149.   }
  150.   return;
  151. }

  153. void Deal_with_function_args(void)
  154. {
  155.   while(')' != this.type)
  156.     Gettoken();
  157.   Gettoken();
  158.   printf("function returning ");
  159.   return;
  160. }

  162. void Deal_with_pointers(void)
  163. {
  164.   while('*' == stack[top].type)
  165.     printf("%s ", pop.string);
  166.   return;
  167. }

shellway@ubuntu:~/code$ gcc cdecl.c
shellway@ubuntu:~/code$ ./a.out
输入一个C语言声明,cdecl程序会把声明转化成通俗文字:
int *p
p is pointer to int
是否进行下一个声明的推断(y\n)?y
int (*pfun)(int,int)
pfun is pointer to function returning int
 
是否进行下一个声明的推断(y\n)?y
char * const *(*next)()
next is pointer to function returning pointer to read-only pointer to char
 
是否进行下一个声明的推断(y\n)?y
char *(*c[10])(int **p)
c is array 0..9 of pointer to function returning pointer to char
 
是否进行下一个声明的推断(y\n)?n
shellway@ubuntu:~/code$


阅读(2363) | 评论(0) | 转发(1) |
0

上一篇：没有了

下一篇：一道腾讯公司的面试题

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6