c语言学习笔记十八

预处理


预处理的步骤：

1 把三连符替换成相应的单字符
替换规则:
??= #
??/ \
??’ ^
??( [
??) ]
??! |
??< {
??> }
??- ~
2 把\字符续行的多行代码接成一行
3 把注释替换成一个空格
4 预处理器把剩下的逻辑代码划分成预处理token和空白字符，
5 在token中识别出预处理指示，作相应动作
#inclucd 引入相应的源文件
宏定义作宏展开
6 替换字符常量和字符串中的转义字符
7 把代码中相邻的字符串连接起来
8 去掉空白字符(空格/换行/水平tab/垂直tab)





宏定义




变量宏定义：
示例代码：
#define N 10
#define STR "hello world!"


函数式宏定义
示例代码：
#define MAX(a,b) ((a)>b?(a):(b))
k=MAX(i&0x0f,j&0x0f)

展开宏定义：cpp test25.c或是gcc -E


与真正函数的区别：
1 参数没有类型，不作参数类型检查，只是形式上的替换
2 生成指令不同
3 内层括号不能省
4 调用函数时先求实参表达式的值再传给形参





内联函数 (inline)
调用时尽可能的快，可以当普通函数调用实现，也可以用宏展开
示例代码：
static inline void down_read(struct rw_semaphore *sem){
might_sleep();
rwsemtrace(sem,"Entering down_read");
_down_read(sem);
rwsemtrace(sem,"Leaving down_read")
}


示例代码如下：


inline int MAX(int a,int b){
return a>b?a:b;
}
int a[]={9,3,5,2,1,0,8,7,6,4};
int max(int n){
return n==0?a[0]:MAX(a[n],max(n-1));
}
int main(void){
max(9);
return 0;
}


编译代码：
gcc test25.c -g

反汇编:(MAX是作为普通函数调用的)
objdump -dS a.out


inline int MAX(int a,int b){
80483b4: 55 push %ebp
80483b5: 89 e5 mov %esp,%ebp
return a>b?a:b;
80483b7: 8b 45 08 mov 0x8(%ebp),%eax
80483ba: 39 45 0c cmp %eax,0xc(%ebp)
80483bd: 0f 4d 45 0c cmovge 0xc(%ebp),%eax
}
80483c1: 5d pop %ebp
80483c2: c3 ret


080483c3 <max>:
int a[]={9,3,5,2,1,0,8,7,6,4};
int max(int n){
80483c3: 55 push %ebp
80483c4: 89 e5 mov %esp,%ebp
80483c6: 83 ec 18 sub $0x18,%esp
return n==0?a[0]:MAX(a[n],max(n-1));
80483c9: 83 7d 08 00 cmpl $0x0,0x8(%ebp)
80483cd: 75 07 jne 80483d6 <max+0x13>
80483cf: a1 40 a0 04 08 mov 0x804a040,%eax
80483d4: eb 24 jmp 80483fa <max+0x37>
80483d6: 8b 45 08 mov 0x8(%ebp),%eax
80483d9: 83 e8 01 sub $0x1,%eax
80483dc: 89 04 24 mov %eax,(%esp)
80483df: e8 df ff ff ff call 80483c3 <max>
80483e4: 8b 55 08 mov 0x8(%ebp),%edx
80483e7: 8b 14 95 40 a0 04 08 mov 0x804a040(,%edx,4),%edx
80483ee: 89 44 24 04 mov %eax,0x4(%esp)
80483f2: 89 14 24 mov %edx,(%esp)
80483f5: e8 ba ff ff ff call 80483b4 <MAX>
}
80483fa: c9 leave
80483fb: c3 ret


080483fc <main>:
int main(void){
80483fc: 55 push %ebp
80483fd: 89 e5 mov %esp,%ebp
80483ff: 83 e4 f0 and $0xfffffff0,%esp
8048402: 83 ec 10 sub $0x10,%esp
max(9);
8048405: c7 04 24 09 00 00 00 movl $0x9,(%esp)
804840c: e8 b2 ff ff ff call 80483c3 <max>
return 0;
8048411: b8 00 00 00 00 mov $0x0,%eax
}
8048416: c9 leave
8048417: c3 ret
8048418: 90 nop
8048419: 90 nop
804841a: 90 nop
804841b: 90 nop
804841c: 90 nop
804841d: 90 nop
804841e: 90 nop
804841f: 90 nop


指定优代选项编译
gcc test25.c -g -O


反汇编：
objdump -dS a.out
可以看到MAX函数的指令被内联在max函数中


#include<stdio.h>
inline int MAX(int a,int b){
8048404: 55 push %ebp
8048405: 89 e5 mov %esp,%ebp
8048407: 8b 45 08 mov 0x8(%ebp),%eax
804840a: 8b 55 0c mov 0xc(%ebp),%edx
804840d: 39 c2 cmp %eax,%edx
804840f: 0f 4d c2 cmovge %edx,%eax
return a>b?a:b;
}
8048412: 5d pop %ebp
8048413: c3 ret


08048414 <max>:
int a[]={3,5,2,1,9,8,7,6,4,10};
int max(int n){
8048414: 55 push %ebp
8048415: 89 e5 mov %esp,%ebp
8048417: 53 push %ebx
8048418: 83 ec 14 sub $0x14,%esp
804841b: 8b 5d 08 mov 0x8(%ebp),%ebx
return n==0?a[0]:MAX(a[n],max(n-1));
804841e: 85 db test %ebx,%ebx
8048420: 75 07 jne 8048429 <max+0x15>
8048422: a1 40 a0 04 08 mov 0x804a040,%eax
8048427: eb 17 jmp 8048440 <max+0x2c>
8048429: 8d 43 ff lea -0x1(%ebx),%eax
804842c: 89 04 24 mov %eax,(%esp)
804842f: e8 e0 ff ff ff call 8048414 <max>
###################################################################
#include<stdio.h>
inline int MAX(int a,int b){
return a>b?a:b;
8048434: 8b 14 9d 40 a0 04 08 mov 0x804a040(,%ebx,4),%edx
804843b: 39 d0 cmp %edx,%eax
804843d: 0f 4c c2 cmovl %edx,%eax
####################################################################
}
int a[]={3,5,2,1,9,8,7,6,4,10};
int max(int n){
return n==0?a[0]:MAX(a[n],max(n-1));
}
8048440: 83 c4 14 add $0x14,%esp
8048443: 5b pop %ebx
8048444: 5d pop %ebp
8048445: c3 ret


08048446 <main>:
int main(void){
8048446: 55 push %ebp
8048447: 89 e5 mov %esp,%ebp
8048449: 83 e4 f0 and $0xfffffff0,%esp
804844c: 83 ec 10 sub $0x10,%esp
//查找集合中前n位的最大值
int temp=0;
temp=max(4);
804844f: c7 04 24 04 00 00 00 movl $0x4,(%esp)
8048456: e8 b9 ff ff ff ca





#,##运算符和可变参数


#用于创建字符串，#后面跟有人形参
示例代码如下：
#define STR(s) # s
STR(hello world)
处理后："hello word"
用""括起来，多个空格变一个空格
如果形参中包含字符常量或是字符串，展开后"变\" \变\\




## 把前后两个预处理连接成一个预处理token，(函数式宏定义和变量宏定义都可以)
示例代码：
#define CONCAT(a,b) a##b
CONCAT(con,cat);
处理后为:concat


...可变参数, __VA_ARGS__代表可变参数部分


示例代码如下：
#define showlist(...) printf(#__VA_ARGS__)
#define report(test, ...) (test)?printf(#test):printf(__VA_ARGS__)
showlist(the first,second,and third items);
report(x>y,"x is %d but y is %d ",x,y);


处理后:
printf("the first,second,third items");
((x>y)?printf("x>y"):printf("x is %d but y is %d ",x,y));



宏展开的部骤：


示例代码：
#define sh(x) printf("n #x"=%d,or %d\n",n##x,alt[x])
#define sub_z 26
sh(sub_z)


过程如下：
1 #x要替换成"sub_z"
2 n##x 换成nsub_z
3 把sub_z 换成26后放到alt[x]的位置
4 结果： printf("n" "sub_z" "=%d,or %d\n",nsub_z,alt[26])