在ANSI C的任何一种实现中,存在两个不同的环境。
第1种是翻译环境,在这个环境中源代码被转换为可执行的机器指令。
第2种是执行环境,它用于实际执行代码。
这里有一个代码:
sum.c
int g_val = 2016;
void print(const char *str) {
printf("%s\n", str);
}
test.c
#include <stdio.h>
int main()
{
extern void print(char *str);
extern int g_val;
printf("%d\n", g_val);
print("hello bit.\n");
return 0;
}
读者可以将上面代码复制到编译器当中运行,当然要分为不同的两个源文件进行存放。运行的结果是不会出现问题的。但是我们如何知道编译器在什么阶段又对哪一部分进行相应的操作呢?
翻译环境与运行环境可以分为几个阶段:
test.c文件最终转换为test.exe文件就是经过上面五个步骤完成的。
而上面五个步骤的具体操作:
读者对于上面具体的步骤肯定会有疑惑,什么是词法分析?段表?符号表?等等。下面我就来一一解释。
在编译阶段中,语义分析、语法分析、词法分析都是用来判断我们程序的源代码是否在语句与词法上出现错误。如果有错误在编译阶段就会停止,并且编译器会自行报错。符号汇总指的是将全局变量为符号汇总起来。如以下代码:
符号汇总后汇总的符号有:
ADD函数与main函数均为全局符号,当然printf也是一个函数,但是此处忽略它。
我们知道了符号是什么,那么符号表又是什么呢?简单意义上来说,就是该全局符号及其地址就是一个符号表。如:(假设ADD函数的地址为0x100,main函数的地址为0x400,生成test.o文件)。
合并段表与合并符号表是什么意思呢?在gcc编译器中,的的确确存在段表,有文本段、数据段等,此处不作详细说明,只是证明在链接过程中存在段表。
在linux系统下,test.o的二进制文件是由elf的格式来组织文件的。只需在gcc编译器底下输入readelf test.o -a
则能看到符号表的汇总。
符号表的重定位则是将全局符号地址相同而没有意义的符号去掉。例如:
ADD有重复的地址,声明的地址是没有意义的,最终只留下定义ADD函数中的符号表。
符号表存在的意义是什么?符号表存在则能够对其他源文件中的函数或全局变量就是合并,即合并符号表,否则无法链接在一起,不同源文件的函数也不能相互使用。
程序执行的过程:
__FILE __ //进行编译的源文件地址 %s
__LINE __ //文件输入该指令的行号 %d
__DATE __ //文件被编译的日期 %s
__TIME __ //文件被编译的时间 %s
__STDC __ //如果编译器遵循ANSI C,其值为1,否则未定义
举个例子:其它指令读者可以自己尝试看看会有什么效果
语法:
#define name stuff
举个例子:
#define MAX 1000
#define reg register //为 register这个关键字,创建一个简短的名字
#define do_forever for(;; ) //用更形象的符号来替换一种实现
#define CASE break;case //在写case语句的时候自动把 break写上。
// 如果定义的 stuff过长,可以分成几行写,除了最后一行外,每行的后面都加一个反斜杠(续行符)。
#define DEBUG_PRINT printf(“file:%s\tline:%d\t
date:%s\ttime:%s\n” ,
_ FILE,LINE_ ,
_ DATE,TIME_ )
注:在define后面不要加;号,否则很容易出错。
例如:在下面的场景中会报错:
#define MAX 1000;
if(condition)
max = MAX; //相当于max=1000;; 两个分号会报错
else
max = 0;
#define 机制包括了一个规定,允许把参数替换到文本中,这种实现通常称为宏(macro)或定义宏(define macro)。
下面是宏的申明方式:#define name( parament-list ) stuff
其中的 parament-list 是一个由逗号隔开的符号表,它们可能出现在stuff中。
注意:
如:
#define SQUARE( x ) x * x
当我们传入参数为5时,SQUARE( 5 )将会替换成为5 * 5,而当我们传入的参数为5+1,很多人会认为结果为36,但是程序运行结果为11。这是什么原因造成的呢?因为运算符有优先级,因此5+1*5+1会先运算1 * 5,在加上5和1,最终结果为11。
解决方法:在宏定义上加上两个括号,这个问题便轻松的解决了:
#define SQUARE(x) (x) * (x)
这里还有一个宏定义:
#define DOUBLE(x) (x) + (x)
定义中我们使用了括号,想避免之前的问题,但是这个宏可能会出现新的错误。例如:
int a = 5;
printf("%d\n" ,10 * DOUBLE(a));
看上去,好像打印100,但事实上打印的是55。替换后为:
printf ("%d\n",10 * (5) + (5));
因此运算结果为55。
解决方法:是在宏定义表达式两边加上一对括号就可以了。
#define DOUBLE(x) ( ( x ) + ( x ) )
提示:
所以用于对数值表达式进行求值的宏定义都应该用这种方式加上括号,避免在使用宏时由于参数中的操作符或邻近操作符之间不可预料的相互作用。
typedef的作用是重命名类型,重命名后的名字就是一个类型。而#define重命名只是名字。例如:
ptr_t p1,p2被替换成为 int* p1,int p2 ,而ptr_t2 p3,p4被替换成为int* p3,int* p4 。
在程序中扩展#define定义符号和宏时,需要涉及几个步骤。
注意:
#的作用
如何把参数插入到字符串中?
首先我们看看这样的代码:
char* p = "hello ""world\n";
printf("hello"," world\n");
printf("%s", p);
我们发现最后输出的仍然是hello world 。我们发现字符串是有自动连接的特点的。
再复杂点我们可以这样写:
#define PRINT(FORMAT, VALUE)\ printf("the value is "FORMAT"\n", VALUE);
...
PRINT("%d", 10);
这里只有当字符串作为宏参数的时候才可以把字符串放在字符串中。打印的结果为the value is 10
。
有一个技巧是:
使用 # ,把一个宏参数变成对应的字符串。
int i = 10;
#define PRINT(FORMAT, VALUE)\ printf("the value of " #VALUE "is "FORMAT "\n", VALUE);
...
PRINT("%d", i+3);
最终的输出的结果应该是:the value of i+3 is 13
当然还有一个作用是能够将一个字符串变为传递给宏的一个参数的变量符号。
例如:
#define PRINT(n) printf("the value of "#n" is %d\n",n)
int main()
{
int a = 10;
PRINT(a);
int b = 20;
PRINT(b);
此处原意是要打印每一个变量的值,并且要在打印中体现出来是哪个变量的值。
打印结果为:
仔细思考一下,这个作用函数能够做到吗?
##的作用
此处就举个简单的例子:
#define cat(X,Y) X##Y
int main()
{
printf("%d",cat(1, 2));
return 0;
}
最终打印的结果为12,为1与2合并的结果。此时肯定有个疑问,12是大小为12还是只是它们合并后为12不具有运算能力呢?我们再验证一下:
#define cat(X,Y) X##Y
int main()
{
printf("%d",cat(1, 2)+1);
return 0;
}
最终打印的结果为13,因此可以证明12即是大小为12,具有计算能力。##可以把位于它两边的符号合成一个符号。它允许宏定义从分离的文本片段创建标识符。这样的连接必须产生一个合法的标识符。否则其结果就是未定义的。
再举一个例子:
#define cat(X,Y) X##Y
int main()
{
int zjruiiiiii = 100;
printf("%d", cat(zjr, uiiiiii));
}
打印的结果为100。原因是##将两个字符串合并,结果为zjruiiiiii,而zjruiiiiii的值为100,以%d的形式打印,则打印的结果为100。
当宏参数在宏的定义中出现超过一次的时候,如果参数带有副作用,那么你在使用这个宏的时候就可能出现危险,导致不可预测的后果。副作用就是表达式求值的时候出现的永久性效果。
例如:
x+1;//不带副作用
x++;//带有副作用
MAX宏可以证明具有副作用的参数所引起的问题:
#define MAX(a, b) ( (a) > (b) ? (a) : (b) )
...
x = 5; y = 8; z = MAX(x++, y++);
printf("x=%d y=%d z=%d\n", x, y, z);//输出的结果是什么?
这里我们得知道预处理器替换之后的结果是什么:
z = ( (x++) > (y++) ? (x++) : (y++));
所以输出的结果是:
x=6 y=10 z=9
因此可能有读者认为函数比宏好,因为函数即使传递的值为x++,产生的副作用也没有宏产生的那么大。但作者认为宏与函数都有自己的优劣势。
宏通常被应用于执行简单的运算。比如在两个数中找出较大的一个。
#define MAX(a, b) ((a)>(b)?(a):(b))
那为什么不用函数来完成这个任务?
原因有二:
当然和宏相比函数也有优势的地方:
宏有时候可以做函数做不到的事情。比如:宏的参数可以出现类型,但是函数做不到。
例如:
#define MALLOC(num, type)\ (type *)malloc(num * sizeof(type))
...
//使用
MALLOC(10, int);//类型作为参数
//预处理器替换之后:
(int *)malloc(10 * sizeof(int));
宏和函数的一个对比:(重点)
属性 | #define定义宏 | 函数 |
---|---|---|
代码长度 | 每次使用时,宏代码都会被插入到程序中。除了非常小的宏之外,程序的长度会大幅度增长 | 函数代码只出现于一个地方;每次使用这个函数时,都调用那个地方的同一份代码 |
执行速度 | 更快 | 存在函数的调用和返回的额外开销,所以相对慢一些 |
操作符优先级 | 宏参数的求值是在所有周围表达式的上下文环境里,除非加上括号,否则邻近操作符的优先级可能会产生不可预料的后果,所以建议宏在书写的时候多些括号。 | 函数参数只在函数调用的时候求值一次,它的结果值传递给函数。表达式的求值结果更容易预测。 |
带有副作用的参数 | 参数可能被替换到宏体中的多个位置,所以带有副作用的参数求值可能会产生不可预料的结果。 | 函数参数只在传参的时候求值一次,结果更容易控制。 |
参数类型 | 宏的参数与类型无关,只要对参数的操作是合法的,它就可以使用于任何参数类型 | 函数的参数是与类型有关的,如果参数的类型不同,就需要不同的函数,即使他们执行的任务是不同的。 |
调试 | 宏是不方便调试的 | 函数是可以逐语句调试的 |
递归 | 宏是不能递归的 | 函数是可以递归的 |
命名约定:
一般来讲函数的宏的使用语法很相似。所以语言本身没法帮我们区分二者。
那我们平时的一个习惯是:
把宏名全部大写
函数名不要全部大写
这条指令用于移除一个宏定义。
形式:#undef NAME //如果现存的一个名字需要被重新定义,那么它的旧名字首先要被移除。
举例:
编译器会报错:没有定义cat 。
许多C 的编译器提供了一种能力,允许在命令行中定义符号。用于启动编译过程。
例如:当我们根据同一个源文件要编译出不同的一个程序的不同版本的时候,这个特性有点用处。(假定某个程序中声明了一个某个长度的数组,如果机器内存有限,我们需要一个很小的数组,但是另外一个机器内存大写,我们需要一个数组能够大写。)
例如:
#include <stdio.h>
int main()
{
int array [ARRAY_SIZE];
int i = 0;
for(i = 0; i< ARRAY_SIZE; i ++)
{
array[i] = i;
}
for(i = 0; i< ARRAY_SIZE; i ++)
{
printf("%d " ,array[i]);
}
printf("\n" );
return 0;
}
编译指令:(可在gcc编译器下运行)
gcc -D ARRAY_SIZE=10 programe.c
在编译一个程序的时候我们如果要将一条语句(一组语句)编译或者放弃是很方便的。因为我们有条件编译指令。
比如说:调试性的代码,删除可惜,保留又碍事,所以我们可以选择性的编译。
例如:
#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__ //如果定义了DEBUG则打印
printf("%d\n", arr[i]);//为了观察数组是否赋值成功。
#endif //__DEBUG__
}
return 0;
}
记住:在使用每一个#if或者#ifdef都要有#endif。类似于if else语句。
常见的条件编译指令:
#if 常量表达式
//...
#endif
//常量表达式由预处理器求值。
如:
#define __DEBUG__ 1
#if __DEBUG__
//..
#endif
2.多个分支的条件编译
#if 常量表达式
//...
#elif 常量表达式
//...
#else
//...
#endif
3.判断是否被定义
#if defined(symbol)
#ifdef symbol
#if !defined(symbol)
#ifndef symbol
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
我们已经知道, #include 指令可以使另外一个文件被编译。就像它实际出现于 #include 指令的地方一样。
这种替换的方式很简单:
预处理器先删除这条指令,并用包含文件的内容替换。
这样一个源文件被包含10次,那就实际被编译10次。
本地文件包含:
#include "filename"
查找策略:先在源文件所在目录下查找,如果该头文件未找到,编译器就像查找库函数头文件一样在标准位置查找头文件。如果找不到就提示编译错误。
VS环境的标准头文件的路径:
C:\Program Files (x86)\Microsoft Visual Studio 12.0\VC\include
Linux环境的标准头文件的路径:
/usr/include
库文件包含
#include <filename.h>
查找策略:查找头文件直接去标准路径下去查找,如果找不到就提示编译错误。
这样是不是可以说,对于库文件也可以使用 “” 的形式包含?
答案是肯定的,可以。但是这样做查找的效率就低些,当然这样也不容易区分是库文件还是本地文件了。
如果出现这种场景:
我们最终会发现comm.h这个头文件最终会被包含两次。要想该头文件只能被包含一次,那么如何解决这个问题呢?
可以使用条件编译。每个头文件的开头写:
#ifndef __TEST_H__
#define __TEST_H__
//头文件的内容
#endif //__TEST_H__
或者:
#pragma once
就可以避免头文件的重复引入。
#error
#pragma
#line
.....
#pragma pack()在结构体部分介绍。用于改变编译器默认对齐数
原创不易,如果此篇文章对你有帮助,麻烦点个赞支持下谢谢!
版权说明 : 本文为转载文章, 版权归原作者所有 版权申明
原文链接 : https://blog.csdn.net/ZJRUIII/article/details/120675132
内容来源于网络,如有侵权,请联系作者删除!