c中#与##的应用思考

c中#与##的应用思考

原创 2014年02月25日 22:01:35

• 927

一. 思考出处

在读<<linux 0.12完全剖析>>初始化部分， init进程是通过fork调用的，在这里fork调用的非常特别，由于种种原因，用的是内嵌汇编的方式

1. #define _syscall0(type, name) \
2. type name(void) \
3. { \
4. long _res;
5. _asm_ volatile ( \
6. "int $0x80\n\t"  \
7. : "=a" (_res) \
8. : "0"(__NR_##name);    \
9. ); \
10. if(_res >= 0) \
11. return (type) _res; \
12. errno = _res; \
13. return -1;   \
14. }

上面看到 _NR_##name， 一下子懵掉了，啥意思这是？

二.思考成果

1.代码解释

不得不说，上面的调用fork方式写的真让我震撼，简单分析一下

前提 : 声明函数 static inline _syscall0(int, fork)   //这里  syscall0中的0代表的是没有输入参数的意思,当然1就代表有一个输入参数

过程:  ①预编译阶段:        //(就是代码还没有编译之前)

static inline _syscall0(int, fork)  将被替换为下面代码

1. static inline int fork(void) \
2. { \
3. long _res;
4. _asm_ volatile ( \
5. "int $0x80\n\t"  \     //系统调用
6. : "=a" (_res) \        //将结果存入寄存器%eax, 并且传给 变量 _res
7. : "0"(_NR_fork);    \  //这里 _NR_fork 在unstd.h中 被#deine 为2， 这里将 _NR_fork 传给寄存器 %eax, 为系统调用做准备
8. ); \
9. if(_res >= 0) \
10. return (type) _res; \
11. errno = _res; \
12. return -1;   \
13. }

②运行阶段:

经编译之后呢， 其实static _sys..那个声明其实对fork函数进行说明并且定义了，所以在程序中直接用 fork() 就可以了

模拟的小例子:

1. #include <stdio.h>
2. #define _NR_hello 10
3. #define SUM(a) \
4. int a() \
5. {  \
6. return _NR_##a + 2; \
7. }
8. static SUM( hello); //这里预编译之后编程下面代码了
9. //int hello()
10. //{
11. //  return _NR_hello + 2; //由于_NR_hello 前面是有定义的，所以直接替换成 10了
12. //}
13. int main()
14. {
15. int c;
16. c=hello(); //程序中直接调用hello就可以了
17. printf("[%d]\n", c);
18. return 0;
19. }

以下的参考： http://zgmgypb.blog.163.com/blog/static/9620281920129145154297/

2.#与##

其实就一句话 #,是声明后面定义的是一个字符串，##是告诉编译器，预编译的时候将 ##前后定义的量和在一起

举例: #

1. #define MA_IF(EXP) \
2. do{ \
3. if(EXP) \
4. fprintf(stderr, "Warning:" #EXP "\n"); \
5. } while(0)

那么实际使用中会出现下面所示的替换过程：

MA_IF (divider == 0);

被替换为

do {
  if (divider == 0)
  fprintf(stderr, "Warning" "divider == 0" "/n");
} while(0);

其实就是 告诉编译器 EXP 是字符串

举例: ##

这里 ##  的应用可作为代码生成器的编写，这里也是受网上材料的启发，下面的例子就是关于加，减指令以及对应处理函数的关联写法,这样写的好处是提高代码密度以及

便于理解 //由于本人菜鸟，这点体会的很别扭

1. #include <stdio.h>
2. struct Arithmetic{
3. char *action_name;
4. int (*func)(int a, int b);
5. };
6. int add_function(int a, int b)
7. {
8. return a+b;
9. }
10. int dev_function(int a, int b)
11. {
12. return a-b;
13. }
14. #define FUNC_REGISTER(name) {#name, name##_function} //这里一定要注意一下 不能写成 {name , name##_function}，原因下面解释 ①
15. int main()
16. {
17. int data1, data2;
18. struct Arithmetic compute[2] = {
19. FUNC_REGISTER(add),  // ②
20. FUNC_REGISTER(dev)
21. };
22. data1 = compute[0].func(1,2);
23. data2 = compute[1].func(2,1);
24. printf("[%d][%d]\n", data1, data2);
25. }

nop： 这里如果写成①这种情况, 那么编译会报错, add，dev没有被定义, 这是为何?
            回答， 不管是#, ##  等等，我们预编译的时候会进行宏替换， 比如，我们#define SUN(a), a    ， 如果我们在main程序中 SUN(1）

则会替换成 1，1的话没什么好说的，因为就是常量嘛，但是如果我们写成SUN(abc),那么编译器就替换成abc，但是编译器不认识abc是什么啊，因为你没有告诉它

同理: 这里写成①的情况，在②中进行宏替换，替换成{abc, name_function} ，这里abc没有被定义，编译器不知道是啥，更别说进行赋值操作，而name_function这个是            有定义的， 是个函数！，所以正确，所以我们必须在name前面加#告诉编译器它是个字符串，就可以了

那么在②中进行宏替换之后，就变成了{"add", name_function}了