目录
1. 预定义符号
C语言设置了一些预定义符号,可以直接使用,预定义符号也是在预处理期间处理的。
__FILE__ //进行编译的源文件
__LINE__ //文件当前的行号
__DATE__ //文件被编译的日期
__TIME__ //文件被编译的时间
__STDC__ //如果编译器遵循ANSI C,其值位1,否则未定义
举例:
#include <stdio.h>
int main()
{
printf("%s\n", __FILE__);//文件名字是字符串,用%s来打印
printf("%d\n", __LINE__);//行号是整型,用%d打印
printf("%s\n", __DATE__);
printf("%s\n", __TIME__);
//printf("%s\n", __STDC__);
//VS编译器下没有这个符号,运行起来报错,说明VS并没有完全遵循ANSIC这个标准
return 0;
}
上面的时间是编译的时间。
gcc编译器下运行:
最后一个值是1,说明gcc编译器是完全遵循ANSI C。
2. #define定义常量
基本语法:
#define name stuff
//name - 名字
//stuff - 内容
下面这段代码在gcc编译器下面测试,便于观察。
#include <stdio.h>
#define M 100//在预编译节点会把M对应的内容替换到M所出现的位置上,并且把这句话删掉
int main()
{
int a = M;
printf("%d\n",M);
return 0;
}
当我们观察的时候,#define定义的那句话就不见了,而且有M的地方都被替换成了100。
其实我们前面的预定义符号也是替换的。
预处理阶段对于这些预定义的符号使用的时候直接就替换成了它的内容。
当然,对于字符串也是一样的,完成替换。所以我们定义符号,什么名字都可以,内容不管什么也可以,它的使用方式就是在使用的时候直接替换。
包括数组也是可以的。
也有时候觉得register写起来太麻烦,也可也定义为reg,预编译之后的效果是一样的。
#define DEBUG_PRINT printf("file:%s\tline:%d\t \
date:%s\ttime:%s\n" ,\
__FILE__,__LINE__ ,\
__DATE__, __TIME__)
也会在后面定义一大段代码,内容可能是多行,如果是多行的时候就需要加"\"(续行符),徐行符后面什么都不能加,其实后面是回车,续行符就是转义回车,让回车不再是回车,否则会有语法问题。
思考:在#define定义标识符的时候,要不要在最后加上分号呢?
#define M 100
#define M 100;
建议不要加上分号,这样容易导致问题。
3. #define定义宏
#define机制包含了一个规定,允许把参数替换到文本中,这种实现通常称为宏(macro)或定义宏(define macro)。
我们从这句话中知道了宏其实是有参数的,所以它才允许把蚕食替换到文本中。
宏的声明方式:
#define name( parament-list ) stuff
//parament-list - 参数列表
//stuff - 内容
//宏允许把参数列表中的东西替换到它的内容中
其中的 parament-list 是一个由逗号隔开的符号表,它们可能出现在stuff(内容)中。
注意:参数列表的左括号必须与name紧邻,如果两者之间有任何空白存在,参数列表就会被解释为stuff(内容)的一部分。
举例:
#include <stdio.h>
//实现一个宏,求平方
#define SQUARE(n) n*n
//SQUARE - 宏的名字
//n - 宏的参数
//n*n - 宏的内容
int main()
{
int x = 0;
scanf("%d",&x);
int ret = SQUARE(x);
printf("%d\n",ret);
return 0;
}
左边是源代码,右边是编译器预编译后的代码。
输入7,输出49。
宏是有参数的,宏在调用的时候最终会被替换成宏的内容,把参数先替换给宏的参数,参数又替换到宏体内,最终是按照内容进行计算。
宏其实和函数是很像的,函数有返回类型,函数名,函数参数,函数体,宏有宏名,宏的参数,宏体,唯一不一样的就是宏没有参数类型,宏适合完成相对简单的任务。
其实这个宏还存在一个问题,那么我不传x了,我传5+1。
#include <stdio.h>
#define SQUARE(n) n*n
int main()
{
int ret = SQUARE(5+1);
printf("%d\n",ret);
return 0;
}
当运行这个代码的时候其实不是算出36,因为宏是完成替换的,那么具体原因是为什么呢?
预编译之后的代码,5+1*5+1这个应该先算1*5,结果是5,然后5+5+1结果是11,所以在替换之前的5+1不会计算成6,它是把5+1直接替换到宏的参数,宏的参数直接替换到宏的体内,然后拿宏的内容替换这次宏调用。宏的参数是不计算,直接替换进去。
在宏定义上加上两个括号,这个问题便轻松的解决了。
所以我们在写宏的时候一定要多加括号。
那么我们再写一个宏,求一个数的二倍。
定义中我们使用了括号,想避免之前的问题,但是这个宏可能会出现新的错误
#include <stdio.h>
#define DOUBLE(x) (x)+(x)
int main()
{
int n = 0;
scanf("%d",&n);
int ret = DOUBLE(n);
printf("%d\n",ret);
return 0;
}
5的二倍是10,10*10是100,但是这里打印的为啥是55呢?
乘法运算先于宏定义的加法,所以出现了55。
这个问题的解决办法就是在宏定义表达式两边加上一对括号就可以而来。
提示:
所有用于对数值表达式进行求值的宏定义都应该用这种方式加上括号,避免在使用宏时由于参数中的操作符或邻近操作符之间不可预料的相互作用。
4. 带有副作用的宏参数
当宏参数在宏的定义中出现超过一次的时候,如果参数带有副作用,那么你在使用这个宏的时候就可能出现危险,导致不可预测的后果。副作用就是表达式求值的时候出现的永久性效果。
#include <stdio.h>
int main()
{
int a = 10;
int b = a + 1;//b = 11,a = 10 这种写法不会对a做出改变
int b = ++a; // b = 11,a = 11 这种写法就会改变a
//所有说第二种写法就是带有副作用的,为了达到某种目的让b得到11
//而a也变化了,而且这个变化彻底就把a改变了
return 0;
}
写一个宏,求两个数的较大值
#include <stdio.h>
#define MAX(x,y) ((x)>(y)?(x):(y))
int main()
{
int a = 12;
int b = 11;
printf("%d\n", MAX(a, b));
return 0;
}
那么我们可以看看预处理之后的结果是什么?
这段代码宏的参数在宏体内出现了两次。
那么如果不传a和b,而传的是a++,b++那么计算的结果是什么呢?
#include <stdio.h>
#define MAX(x,y) ((x)>(y)?(x):(y))
int main()
{
int a = 12;
int b = 11;
printf("%d\n", MAX(a++, b++));
return 0;
}
a++和b++都是先用后++,所以是12>11?13:?,所以输出的结果是13。所以在这个代码中a++执行了额两次,而b++执行了一次,宏的参数一旦带有副作用的时候,当我替换进去的时候这个副作用就会产生两次++的效果,这种行为是非常可怕的。
5. 宏替换的规则
在程序中扩展#define定义符号和宏时,需要涉及几个步骤。
- 在调用宏时,首先对参数进行检查,看看是否包含任何由#define定义的符号。如果是,它们首先被替换。
#include <stdio.h> #define M 100 #define MAX(x,y) ((x)>(y)?(x):(y)) int main() { int m = MAX(M, 110);//参数M就是#define定义的符号,M首先被替换 printf("%d\n", m); return 0; }
-
替换文本随后被插入到程序中原来文本的位置。对于宏,参数名被它们的值所替换。
-
最后,再次对结果文件进行扫描,看看它是否包含任何由#define定义的符号。如果是,就重复上述处理过程。
注意:
- 宏参数和#define定义中可以出现其他#define定义的符号。但是对于宏,不能出现递归。
#include <stdio.h> #define M 100 #define N M+2//#define定义的符号里面可以出现#define定义的符号M #define MAX(x,y) ((x)>(y)?(x):(y))//但是宏不能递归,不能在MAX宏体内调用MAX宏 int main() { int m = MAX(M, 110);//调用宏的时候宏的参数可以出现#define出现的符号M printf("%d\n", m); return 0; }
-
当预处理器搜索#define定义的符号的时候,字符串常量的内容并不会被搜索。
#include <stdio.h> #define M 100 #define N M+2 #define MAX(x,y) ((x)>(y)?(x):(y)) int main() { int m = MAX(M, 110); printf("MAX(M, 110)");//这个M不会替换成100,因为这个M是字符串的内容 return 0; }
6. 宏和函数的对比
没有返回类型
#define MAX(x,y) ((x)>(y)?(x):(y))
//函数 - 函数参数是有类型的
//函数是有函数体的
//函数有返回类型
int Max(int x,int y)
{
return x > y ? x : y;
}
int main()
{
int m = MAX(10, 20);
printf("%d\n", m);
int n = Max(10, 20);
printf("%d\n", n);
return 0;
}
宏通常被应用于执行简单的运算。
比如在两个数中找出较大的一个值时,写成下面的宏,更有优势一些。
#define MAX(x,y) ((x)>(y)?(x):(y))
那为什么不用函数来完成这个任务呢?
原因有二:
- 用于调用函数和从函数返回的代码可能比实际执行这个小型计算工作所需要的实际更多。所以宏比函数在程序的规模和速度方面更胜一筹。
- 更为重要的是函数的参数必须声明为特定的类型,而宏参数没有类型。所以函数只能在类型合适的表达式上使用。反之这个宏可以适用于整型,长整型,浮点型等可以用于>来比较的类型。宏的参数是类型无关的。
和函数相比宏的劣势:
- 每次使用宏的时候,一份宏定义的代码将插入到程序中。除非宏比较短,否则可能大幅度增加程序的长度。
- 宏是没法调试的。
- 宏由于类型无关,也就不够严谨。
- 宏可能会带来运算符优先级的问题,导致程序容易出现错误。宏的参数是替换进去,而函数是计算好传进去的。
宏有时候可以做函数做不到的事情。比如:宏的参数可以出现类型,但是函数做不到。
#include <stdio.h>
#define MALLOC(type,x) (type*)malloc(sizeof(type)*x)//只有宏可以做到,函数做不到
int main()
{
//以前我们写malloc是这样写的
int* p = (int*)malloc(sizeof(int) * 10);
//现在可以写成宏
int* arr = MALLOC(int, 10);
//宏替换后的结果
//int* arr = (int*)malloc(sizeof(int) * 10);
return 0;
}
宏和函数的一个对比
7. #和##
这个#可不是#define前面的#,也不是#include前面的#,而是一种单独的运算符。
7.1 #运算符
#运算符将宏的一个参数转换为字符串字面量。它仅允许出现在带参数的宏的替换列表中。
#运算符所执行的操作可以理解为"字符串化"。
当我们有一个变量int a = 10;的时候,我们想打印出:the value of a is 10.那么就可以这样写:
#include <stdio.h>
int main()
{
int a = 10;
printf("this value of a is %d\n", a);
int b = 20;
printf("this value of b is %d\n", b);
return 0;
}
两个打印的代码是一样的,那么就可以写成函数或者是宏了。
但是这个函数是肯定做不到的。
所以写成函数的形式是解决不了问题的。
那么这个问题就可以用宏解决,在写宏之前我们必须知道两个字符串可以合成一个字符串。
#include <stdio.h>
int main()
{
//比如我现在想打印hello world
printf("hello world\n");
//那么我也可以这样写
printf("hello" " world\n");
return 0;
}
那么我们就可以使用宏来解决上面的问题, 既能适用于整型又能适用于浮点型。
#include <stdio.h>
#define PRINT(fromat,val) printf("this value of " #val " is " fromat "\n" , val)
int main()
{
int a = 10;
PRINT("%d",a);
//printf("this value of a is %d\n", a);
int b = 20;
PRINT("%d", b);
//printf("this value of b is %d\n", b);
float f = 5.5f;
PRINT("%f", f);
//printf("this value of f is %f\n", f);
/*
%f给format,f给val,那么出现n的地方替换为f,出现#n的地方替换为"f",
*/
return 0;
}
7.2 ##运算符
##可以把位于它两边的符号合成一个符号,它允许宏定义从分离的文本片段创建标识符。##被称为记号粘合。
这样的连接必须产生一个合法的标识符。否则其结果就是未定义的。
这里我们想想,写一个函数求两个数的较大值的时候,不同的数据类型就得写不同的函数。
int int_max(int x, int y)
{
return x>y?x:y;
}
float float_max(float x, float y)
{
return x>yx:y;
}
但是这样写起来太繁琐了,那么我们可以写一个宏。
#include <stdio.h>
//生成函数的模板,调用一次就定义一个函数
#define GENERIC_MAX(type)\
type type##_max(type x,type y)\
{\
return x>y?x:y;\
}
//使用这个模板生成名字叫:int_max的函数
GENERIC_MAX(int)
//使用这个模板生成名字叫:float_max的函数
GENERIC_MAX(float)
int main()
{
return 0;
}
使用定义的函数
int main()
{
printf("%d\n", int_max(10, 20));
printf("%f\n", float_max(3.5f, 4.5f));
return 0;
}
输出:
8. 命名约定
一般来讲函数和宏的使用语法很相似。所以语言本身没法帮我们区分二者。
那么我i吗平时的一个习惯就是:
把宏名全部大写
函数名不要全部大写
但是有个例:offsetof -- 宏,但是它全是小写
9. #undef
#undef NAME
//如果现存的一个名字需要被重新定义,那么它的旧名字首先要被移除。
#include <stdio.h>
#define M 100//定义标识符M
int main()
{
printf("%d\n", M);//打印M
#undef M;//取消M这个符号
//printf("%d\n", M);//这里使用M就不行了
return 0;
}
10. 命令行定义
许多的C语言编译器都提供了这个,但是VS上用不上这个。
许多C的编译器提供了一种能力,允许在命令行中定义符号。用于启动编译过程。
例如:当我们根据同一个源文件要编译出一个程序不同版本的时候,这个特性有点用处。(假定某个程序中声明了⼀个某个长度的数组,如果机器内存有限,我们需要⼀个很小的数组,但是另外⼀个机器内存⼤些,我们需要⼀个数组能够大些。)
该代码在gcc编译器下面运行。
#include <stdio.h>
int main()
{
int arr[SZ] = {0};
for(int i = 0;i < SZ;i++)
{
arr[i] = i+1;
}
for(int i = 0;i < SZ;i++)
{
printf("%d ",arr[i]);
}
return 0;
}
//注意:SZ我没有定义,因为等会编译的时候会指定SZ的值
//关机命名:
shutdown -s -t 60
//-s -t是命令行的参数
运行的时候指定SZ的值:
gcc main.c -D SZ=10 -o main
输出结果:
所以我们在程序编译的过程中根据需要来指定代码中的常量的值,就叫命令行定义。
11. 条件编译
满足条件,参与编译,不满足条件就不参与编译。
在编译一个程序的时候我们如果要将一条语句(一组语句)编译或者放弃是很方便的。
因为我们有条件编译指令。、
比如:
调试性的代码,删掉可惜,保留又爱是,所以我们可以选择性的编译。
#include <stdio.h>
#define __DEBUG__
int main()
{
int i = 0;
int arr[10] = { 0 };
for (i = 0; i < 10; i++)
{
arr[i] = i;
#ifdef __DEBUG__
printf("%d\n", arr[i]);//为了观察数组是否赋值成功。
#endif //__DEBUG__
}
return 0;
}
常见的条件编译指令:
11.1 单分支条件编译
#if 常量表达式
//...
#endif
//常量表达式由预处理器求值。
如:
#define __DEBUG__ 1
#if __DEBUG__
//..
#endif
其实这也是预处理,下面我把这段代码放到gcc编译器下可以看一下。
当我们替换完之后就只剩打印了,这些预处理指令直接就没有了。
条件为假,不参与编译,打印语句也会被干掉。
#include <stdio.h>
int main()
{
int a = 2;
#if a == 2//后面必须是常量表达式,不能是变量
printf("haha\n");
#endif
return 0;
}
这里的a==2条件为真,可是依然没有打印,原因就是使用了变量, 这种写法是错误的。
11.2 多个分支的条件编译
#if 常量表达式
//...
#elif 常量表达式
//...
#else
//...
#endif
#endif和前面的#if搭配使用。
#include <stdio.h>
#define M 5
int main()
{
#if M==1
printf("hehe\n");
#elif M==3
printf("haha\n");
#elif M==4
printf("heihei\n");
#else
printf("呵呵\n");
#endif
}
这段代码M不等于1,3,4,所以最终走了#else,打印汉字的呵呵。
M等于1,所以条件成立,打印hehe,这个跟if else语句是一样的。
11.3 判断是否被定义
#if defined(symbol)
#ifdef symbol
#if !defined(symbol)
#ifndef symbol
#include <stdio.h>
int main()
{
#if defined(WH)
printf("WH\n");
#endif
return 0;
}
代码中没有定义WH这个符号,所以为假,所以WH就不会打印。
#include <stdio.h>
#define WH 1//这个后面的值不重要,只要定义就行,定义0也可以
int main()
{
#if defined(WH)
printf("WH\n");
#endif
return 0;
}
定义了该符号,为真,所以WH就会打印。
这种代码还有另外一种写法。
前面的是定义了就参与编译,没定义就不参与编译,那么还有它的相反逻辑,也就是定义就不参与编译,没定义就参与编译。
上面的代码还有另外一种写法。
11.4 嵌套指令
#if defined(OS_UNIX)
#ifdef OPTION1
unix_version_option1();
#endif
#ifdef OPTION2
unix_version_option2();
#endif
#elif defined(OS_MSDOS)
#ifdef OPTION2
msdos_version_option2();
#endif
#endif
这种写法在头文件中应用比较多。
同一段代码支持跨平台的话就要用到条件编译。
12. 头文件的包含
12.1 头文件被包含的方式:
12.1.1 本地文件包含
本地文件也就是自己创建的头文件。
#include "filename"
查找策略:
先在源文件所在目录下查找,如果该头文件未找到,编译器就像查找库函数头文件一样在标准位置查找头文件。如果找不到就提示编译错误。
Linux环境下的标准头文件的路径:
/usr/include
VS环境的标准头文件的路径:
C:\Program Files (x86)\Microsoft Visual Studio 12.0\VC\include
//这是VS2013的默认路径
自VS2013之后这个库中的头文件就被分开放在了很多地方,导致比较难找。
C:\Program Files (x86)\Microsoft Visual Studio\2019\Professional\VC\Tools\MSVC\14.29.30133\include
//VS2019默认路径
源文件路径下和库中都找不到,就会报错。
12.1.2 库文件包含
#include <filename.h>
查找头文件直接去标准路径下去查找,如果找不到就提示编译错误。
这样是不是可以说,对于库文件也可以使用" "的形式包含?
答案是肯定可以的,但是这样做查找的效率就低些,当然这样也不容易区分是库文件还是本地文件。
12.2 嵌套文件包含
我们已经知道,#include指令可以使另外一个文件被编译,就像它实际出现于#include指令的地方一样。
这种替换的方式很简单:预处理先删除这条指令,并用包含文件的内容替换。
一个头文件被包含10次,那就实际被编译10次,如果重复包含,对编译的压力就比较大。
//main.c
#include "test.h"
#include "test.h"
#include "test.h"
#include "test.h"
#include "test.h"
int main()
{
return 0;
}
//test.h
void test();
struct Stu
{
int id;
char name[20];
};
如果直接这样写,main.c文件中将test.h包含5次,那么test.h文件的内容将会被拷贝5份在main.c中。
如果test.h文件比较大,这样预处理后代码量会剧增。如果工程比较大,有公共使用的头文件,被大家都能使用,又不做任何的处理,那么后果真的不堪设想。
如果解决头文件被重复引用的问题呢?
答案:条件编译。
每个头文件的开头这样写:
#ifndef __TEST_H__//符号名字根据文件名字来起,自己随便定义
#define __TEST_H__
//头文件的内容
#endif
#ifndef __TEST_H__ 如果没有定义这个符号就执行下面,如果是第一次的话就肯定没有定义,所以执行下面的
#define __Test_H__ 定于这个符号
main.c中还是包含了5次,但是预编译之后是1次。
除了上面的方式,还有一种方式。
#pragma once
加上#pragma once头文件多次包含预编译之后也是一份。
《高质量C/C++编程指南》中附录的考试试卷(很重要)。
《C语言深度解剖》学习