C51几个预编译指令的用法

C51几个预编译指令的用法

标签: 指令用法编译2009-07-31 10:47

预处理过程扫描源代码，对其进行初步的转换，产生新的源代码提供给编译器。可见预处理过程先于编译器对源代码进行处理。

在C语言中，并没有任何内在的机制来完成如下一些功能：在编译时包含其他源文件、定义宏、根据条件决定编译时是否包含某些代码。要完成这些工作，就需要使用预处理程序。尽管在目前绝大多数编译器都包含了预处理程序，但通常认为它们是独立于编译器的。预处理过程读入源代码，检查包含预处理指令的语句和宏定义，并对源代码进行响应的转换。预处理过程还会删除程序中的注释和多余的空白字符。

预处理指令是以#号开头的代码行。#号必须是该行除了任何空白字符外的第一个字符。#后是指令关键字，在关键字和#号之间允许存在任意个数的空白字符。整行语句构成了一条预处理指令，该指令将在编译器进行编译之前对源代码做某些转换。下面是部分预处理指令：

指令用途

#空指令，无任何效果

#include包含一个源代码文件

#define定义宏

#undef取消已定义的宏

#if如果给定条件为真，则编译下面代码

#ifdef如果宏已经定义，则编译下面代码

#ifndef如果宏没有定义，则编译下面代码

#elif如果前面的#if给定条件不为真，当前条件为真，则编译下面代码

#endif结束一个#if……#else条件编译块

#error停止编译并显示错误信息

一、文件包含

#include预处理指令的作用是在指令处展开被包含的文件。包含可以是多重的，也就是说一个被包含的文件中还可以包含其他文件。标准C编译器至少支持八重嵌套包含。

预处理过程不检查在转换单元中是否已经包含了某个文件并阻止对它的多次包含。这样就可以在多次包含同一个头文件时，通过给定编译时的条件来达到不同的效果。例如：

#define AAA

#include "t.c"

#undef AAA

#include "t.c"

为了避免那些只能包含一次的头文件被多次包含，可以在头文件中用编译时条件来进行控制。例如：

#ifndef MY_H

#define MY_H

……

#endif

在程序中包含头文件有两种格式：

#include

#include "my.h"

第一种方法是用尖括号把头文件括起来。这种格式告诉预处理程序在编译器自带的或外部库的头文件中搜索被包含的头文件。第二种方法是用双引号把头文件括起来。这种格式告诉预处理程序在当前被编译的应用程序的源代码文件中搜索被包含的头文件，如果找不到，再搜索编译器自带的头文件。

采用两种不同包含格式的理由在于，编译器是安装在公共子目录下的，而被编译的应用程序是在它们自己的私有子目录下的。一个应用程序既包含编译器提供的公共头文件，也包含自定义的私有头文件。采用两种不同的包含格式使得编译器能够在很多头文件中区别出一组公共的头文件。

二、宏

宏定义了一个代表特定内容的标识符。预处理过程会把源代码中出现的宏标识符替换成宏定义时的值。宏最常见的用法是定义代表某个值的全局符号。宏的第二种用法是定义带参数的宏，这样的宏可以象函数一样被调用，但它是在调用语句处展开宏，并用调用时的实际参数来代替定义中的形式参数。

1.#define指令

#define预处理指令是用来定义宏的。该指令最简单的格式是：首先神明一个标识符，然后给出这个标识符代表的代码。在后面的源代码中，就用这些代码来替代该标识符。这种宏把程序中要用到的一些全局值提取出来，赋给一些记忆标识符。

#define MAX_NUM 10

int array[MAX_NUM];

for(i=0;i

在这个例子中，对于阅读该程序的人来说，符号MAX_NUM就有特定的含义，它代表的值给出了数组所能容纳的最大元素数目。程序中可以多次使用这个值。作为一种约定，习惯上总是全部用大写字母来定义宏，这样易于把程序红的宏标识符和一般变量标识符区别开来。如果想要改变数组的大小，只需要更改宏定义并重新编译程序即可。

宏表示的值可以是一个常量表达式，其中允许包括前面已经定义的宏标识符。例如：

#define ONE 1

#define TWO 2

#define THREE (ONE+TWO)

注意上面的宏定义使用了括号。尽管它们并不是必须的。但出于谨慎考虑，还是应该加上括号的。例如：

six=THREE*TWO;

预处理过程把上面的一行代码转换成：

six=(ONE+TWO)*TWO;

如果没有那个括号，就转换成six=ONE+TWO*TWO;了。

宏还可以代表一个字符串常量，例如：

#define VERSION "Version 1.0 Copyright(c) 2003"

2.带参数的#define指令

带参数的宏和函数调用看起来有些相似。看一个例子：

#define Cube(x) (x)*(x)*(x)

可以时任何数字表达式甚至函数调用来代替参数x。这里再次提醒大家注意括号的使用。宏展开后完全包含在一对括号中，而且参数也包含在括号中，这样就保证了宏和参数的完整性。看一个用法：

int num=8+2;

volume=Cube(num);

展开后为(8+2)*(8+2)*(8+2);

如果没有那些括号就变为8+2*8+2*8+2了。

下面的用法是不安全的：

volume=Cube(num++);

如果Cube是一个函数，上面的写法是可以理解的。但是，因为Cube是一个宏，所以会产生副作用。这里的擦书不是简单的表达式，它们将产生意想不到的结果。它们展开后是这样的：

volume=(num++)*(num++)*(num++);

很显然，结果是10*11*12,而不是10*10*10;

那么怎样安全的使用Cube宏呢？必须把可能产生副作用的操作移到宏调用的外面进行：

int num=8+2;

volume=Cube(num);

num++;

3.#运算符

出现在宏定义中的#运算符把跟在其后的参数转换成一个字符串。有时把这种用法的#称为字符串化运算符。例如：

#define PASTE(n) "adhfkj"#n

main()

{

printf("%s\n",PASTE(15));

}

宏定义中的#运算符告诉预处理程序，把源代码中任何传递给该宏的参数转换成一个字符串。所以输出应该是adhfkj15。

4.##运算符

##运算符用于把参数连接到一起。预处理程序把出现在##两侧的参数合并成一个符号。看下面的例子：

#define NUM(a,b,c) a##b##c

#define STR(a,b,c) a##b##c

main()

{

printf("%d\n",NUM(1,2,3));

printf("%s\n",STR("aa","bb","cc"));

}

最后程序的输出为:

123

aabbcc

千万别担心，除非需要或者宏的用法恰好和手头的工作相关，否则很少有程序员会知道##运算符。绝大多数程序员从来没用过它。

三、条件编译指令

条件编译指令将决定那些代码被编译，而哪些是不被编译的。可以根据表达式的值或者某个特定的宏是否被定义来确定编译条件。

1.#if指令

#if指令检测跟在制造另关键字后的常量表达式。如果表达式为真，则编译后面的代码，知道出现#else、#elif或#endif为止；否则就不编译。

2.#endif指令

#endif用于终止#if预处理指令。

#define DEBUG 0

main()

{

#if DEBUG

printf("Debugging\n");

#endif

printf("Running\n");

}

由于程序定义DEBUG宏代表0，所以#if条件为假，不编译后面的代码直到#endif，所以程序直接输出Running。

如果去掉#define语句，效果是一样的。

3.#ifdef和#ifndef

#define DEBUG

main()

{

#ifdef DEBUG

printf("yes\n");

#endif

#ifndef DEBUG

printf("no\n");

#endif

}

#if defined等价于#ifdef; #if !defined等价于#ifndef

4.#else指令

#else指令用于某个#if指令之后，当前面的#if指令的条件不为真时，就编译#else后面的代码。#endif指令将中指上面的条件块。

#define DEBUG

main()

{

#ifdef DEBUG

printf("Debugging\n");

#else

printf("Not debugging\n");

#endif

printf("Running\n");

}

5.#elif指令

#elif预处理指令综合了#else和#if指令的作用。

#define TWO

main()

{

#ifdef ONE

printf("1\n");

#elif defined TWO

printf("2\n");

#else

printf("3\n");

#endif

}

程序很好理解，最后输出结果是2。

6.其他一些标准指令

#error指令将使编译器显示一条错误信息，然后停止编译。

#line指令可以改变编译器用来指出警告和错误信息的文件号和行号。

#pragma指令没有正式的定义。编译器可以自定义其用途。典型的用法是禁止或允许某些烦人的警告信息。

gcc编译器使用简明指南

gcc编译器使用简明指南 gcc对文件的处理需要经过预处理->编译->汇编->链接的步骤，从而产生一个可执行文件，各部分对应不同的文件类型，具体如下： file.c c程序源文件 file.i c程序预处理后文件 file.cxx c++程序源文件，也可以是https://www.wendangku.net/doc/6a375602.html, / file.cpp / file.c++ file.ii c++程序预处理后文件 file.h c/c++头文件 file.s 汇编程序文件 file.o 目标代码文件 gcc [选项]文件列表 -ansi 强制完全ANSI一致 -c 仅编译或汇编，生成目标代码文件，将.c、.i、.s等文件生成.o文件，其余文件被忽略 -S 仅编译，不进行汇编和链接，将.c、.i等文件生成.s文件，其余文件被忽略 -E 仅预处理，并发送预处理后的.i文件到标准输出，其余文件被忽略 -o file 创建可执行文件并保存在file中，而不是默认文件a.out -g 产生用于调试和排错的扩展符号表，用于GDB调试，切记-g和-O通常不能一起使用 -w 取消所有警告 -W 给出更详细的警告 -O [num]优化，可以指定0-3作为优化级别，级别0表示没有优化 -x language 默认为-x none，即依靠后缀名确定文件类型，加上-x lan确定后面所有文件类型，直到下一个-x出现为止 -D macro[=]类似于源程序里的#define，在-D macro中的macro可被源程序识别，例如gcc -D NUM -D FILE=\"bbs.txt\" hello.c -o hello，第一个-D选项定义宏NUM，在程序中可以使用#ifdef来检查是否被设置，第二个-D定义宏FILE，在源程序中可用 -U macro 类似于源程序开头定义#undef macro，也就是取消源程序中的某个宏定义

C语言习题集(预处理命令篇)

第六章预处理命令 6．1 选择题 1．下面叙述中正确的是（）。 A. 带参数的宏定义中参数是没有类型的 B. 宏展开将占用程序的运行时间 C. 宏定义命令是C语言中的一种特殊语句 D. 使用#include命令包含的头文件必须以“.h”为后缀 2．下面叙述中正确的是（）。 A. 宏定义是C语句，所以要在行末加分号 B. 可以使用#undef命令来终止宏定义的作用域 C. 在进行宏定义时，宏定义不能层层嵌套 D. 对程序中用双引号括起来的字符串内的字符，与宏名相同的要进行置换 3．在“文件包含”预处理语句中，当#include后面的文件名用双引号括起时，寻找被包含文件的方式为（）。 A. 直接按系统设定的标准方式搜索目录 B. 先在源程序所在目录搜索，若找不到，再按系统设定的标准方式搜索 C. 仅仅搜索源程序所在目录 D. 仅仅搜索当前目录 4．下面叙述中不正确的是（）。 A. 函数调用时，先求出实参表达式，然后带入形参。而使用带参的宏只是进行简单的 字符替换 B. 函数调用是在程序运行时处理的，分配临时的内存单元。而宏展开则是在编译时进 行的，在展开时也要分配内存单元，进行值传递 C. 对于函数中的实参和形参都要定义类型，二者的类型要求一致，而宏不存在类型问 题，宏没有类型 D. 调用函数只可得到一个返回值，而用宏可以设法得到几个结果 5．下面叙述中不正确的是（）。 A. 使用宏的次数较多时，宏展开后源程序长度增长。而函数调用不会使源程序变长 B. 函数调用是在程序运行时处理的，分配临时的内存单元。而宏展开则是在编译时进 行的，在展开时不分配内存单元，不进行值传递 C. 宏替换占用编译时间 D. 函数调用占用编译时间 6．下面叙述中正确的是( )。 A. 可以把define和if定义为用户标识符 B. 可以把define定义为用户标识符，但不能把if定义为用户标识符 C. 可以把if定义为用户标识符，但不能把define定义为用户标识符 D. define和if都不能定义为用户标识符 7．下面叙述中正确的是（）。 A.#define和printf都是C语句 B.#define是C语句，而printf不是 C.printf是C语句，但#define不是 D.#define和printf都不是C语句

c语言中预编译指令的应用

#if #ifdef和#ifndef的用法和区别 #if #ifdef和#ifndef用法 移位运算符的优先级高于条件运算符，重载是不能改变运算符优先级的，这点要注意，所以代码应当像下面这样调整，写宏的时候一定要注意优先级，尽量用括号来屏蔽运算符优先级。#define MAXIMUM(x,y) ((x)>(y)?(x):(y)) #define MINIMUM.... #include #define MAX #define MAXIMUM(x,y) x>y?x:y #define MINIMUM(x,y) x

1、GCC编译器的使用

linux下gcc编译器的使用 1、文件后缀名 .c C 源程序 .C C++ 源程序 .cc C++ 源程序 .cxx C++ 源程序 .m Objective –C源程序 .i 预处理过的c源程序 .ii 预处理过的C++源程序 .s 组合语言源程序 .S 组合语言源程序 .h 头文件 .o 目标文件 .a 存档文件 2、GCC常用选项 -c 通知GCC取消链接步骤，即编译源码并在最后生成目标文件； -Dmacro定义指定的宏，使它能够通过源码中的#ifdef进行检验 #define -static 指定程序编译时采用静态编译的方法； -E 不经过编译预处理程序的输出而输送至标准输出； -g获得有关调试程序的详细信息，它不能与-o选项联合使用； -Idirectory在包含文件搜索路径的起点处添加指定目录； -llibrary提示链接程序在创建最终可执行文件时包含指定的库； -O、-O2、-O3将优化状态打开，该选项不能与-g选项联合使用； -S要求编译程序生成来自源代码的汇编程序输出； -v启动所有警报； -Wall发生警报时取消编译操作，即将警报看作是错误； -Werror在发生警报时取消编译操作，即把报警当作是错误； -w 禁止所有的报警。 目前Linux下最常用的C语言编译器是GCC（GNU Compiler Collection），它是GNU项目中符合ANSI C标准的编译系统，能够编译用C、C++和Object C等语言编写的程序。GCC不仅功能非常强大，结构也异常灵活。最值得称道的一点就是它可以通过不同的前端模块来支持各种语言，如Java、 Fortran、Pascal、Modula-3和Ada等。开放、自由和灵活是Linux的魅力所在，而这一点在GCC上的体现就是程序员通过它能够更好地控制整个编译过程。

编译预处理

第九章编译预处理 9.1 选择题 【题9.1】以下叙述中不正确的是。 A）预处理命令行都必须以#号开始 B）在程序中凡是以#号开始的语句行都是预处理命令行 C）C程序在执行过程中对预处理命令行进行处理 D）以下是正确的宏定义 #define IBM_PC 【题9.2】以下叙述中正确的是。 A）在程序的一行上可以出现多个有效的预处理命令行 B）使用带参的宏时，参数的类型应与宏定义时的一致 C）宏替换不占用运行时间，只占编译时间 D）在以下定义中C R是称为“宏名”的标识符 #define C R 045 【题9.3】请读程序： #define ADD(x) x+x main() { int m=1,n=2,k=3; int sum=ADD(m+n)*k; printf(“sum=%d”,sum); } 上面程序的运行结果是。 A）sum=9 B）sum=10 C）sum=12 D）sum=18 【题9.4】以下程序的运行结果是。 #define MIN(x,y) (x)<(y)?(x):(y) main() { int i=10,j=15,k; k=10*MIN(i,j); printf(“%d\n”,k); } A）10 B）15 C）100 D）150 【题9.5】在宏定义#define PI 3.14159中，用宏名PI代替一个。 A）常量B）单精度数C）双精度数D）字符串

【题9.6】以下程序的运行结果是。 #include #define FUDGE(y) 2.84+y #define PR(a) printf(“%d”,(int)(a)) #define PRINT1(a) PR(a); putchar(‘\n’) main() { int x=2; PRINT1(FUDGE(5)*x); } A）11 B）12 C）13 D）15 【题9.7】以下有关宏替换的叙述不正确的是。 A）宏替换不占用运行时间B）宏名无类型 C）宏替换只是字符替换D）宏名必须用大写字母表示 【题9.8】C语言的编译系统对宏命令的处理是。 A）在程序运行时进行的 B）在程序连接时进行的 C）和C程序中的其它语句同时进行编译的 D）在对源程序中其它成份正式编译之前进行的 【题9.9】若有宏定义如下： #define X 5 #define Y X+1 #define Z Y*X/2 则执行以下printf语句后，输出结果是。 int a; a=Y; printf(“%d\n”,Z); printf(“%d\n”,--a); A）7 B）12 C）12 D）7 6 6 5 5 【题9.10】若有以下宏定义如下： #define N 2 #define Y(n) ((N+1)*n) 则执行语句z=2*(N+Y(5));后的结果是。 A）语句有错误B）z=34 C）z=70 D）z无定值 【题9.11】若有宏定义：#define MOD(x,y) x%y 则执行以下语句后的输出为。 int z,a=15,b=100; z=MOD(b,a); printf(“%d\n”,z++);

C中的预处理命令

C中的预处理命令是由ANSIC统一规定的，但它不是C语言的本身组成部分，不能直接对它们进行编译，因为编译程序无法识别它们。必须对程序进行通常的编译（包括词法和语法分析，代码生成，优化等）之前，先对程序中这些特殊的命令进行“预处理”，例如：如果程序中用#include命令包含一个文件“stdio.h”，则在预处理时，将stdio.h文件中的实际内容代替该命令。经过预处理后的程序就像没有使用预处理的程序一样干净了，然后再由编译程序对它进行编译处理，得到可供执行的目标代码。现在的编译系统都包括了预处理，编译和连接部分，在进行编译时一气呵成。我们要记住的是预处理命令不是C语言的一部分，它是在程序编译前由预处理程序完成的。 C提供的预处理功能主要有三种：宏定义，文件包含，条件编译。它们的命令都以“#”开头。 一，宏定义：用一个指定的标识符来代表一个字符串，它的一般形式为： #define 标识符字符串 #define PI 3.1415926 我们把标识符称为“宏名”，在预编译时将宏名替换成字符串的过程称为“宏展开”，而#define 是宏定义命令。 几个应该注意的问题： 1，是用宏名代替一个字符串，也就是做简单的置换，不做正确性检查，如把上面例子中的1写为小写字母l，预编译程序是不会报错的，只有在正式编译是才显示出来。 2，宏定义不是C语句，不必在行未加分号，如果加了分号则会连分号一起置换。 3，#define语句出现在程序中函数的外面，宏名的有效范围为定义命令之后到本源文件结束，通常#define命令写在文件开头，函数之前，作为文件的一部分，在此文件范围内有效。4，可以用#undef命令终止宏定义的作用域。如： #define PI 3.1415926 main(){ } #undef PI mysub(){ } 则在mysub中PI 不代表3.1415926。 5，在进行宏定义时，可以引用已定义的宏名，可以层层置换。 6，对程序中用双撇号括起来的字符串内的字符，即使与宏名相同，也不进行置换。 7，宏定义是专门用于预处理命令的一个专有名词，它与定义变量的含义不同，只做字符替换不做内存分配。 带参数的宏定义，不只进行简单的字符串替换，还进行参数替换。定义的一般形式为：#define 宏名（参数表）字符串 如：#define S(a,b) a*b,具体使用的时候是int area; area=(2,3); 对带参数的宏定义是这样展开置换的：在程序中如果有带参数的宏（如area=(2,3)），则按#define命令行中指定的字符串从左到右进行置换。如果串中包含宏中的形参（如a,b），则将程序语句中的相关参数（可以是常量，变量，或表达式）代替形参。如果宏定义中的字符串中的字符不是参数字符（如上*），则保留，这样就形成了置换的字符串。 带参数的宏与函数有许多相似之处，在调用函数时也是在函数名后的括号内写实参，也要求实参与形参的数目相等，但它们之间还有很大的不同，主要有： 1，函数调用时，先求出实参表达式的值，然后代入形参，而使用带参的宏只是进行简单的字符替换。

实验三 vi编辑器及GCC编译器的使用

实验三vi编辑器及GCC编译器的使用 【实验目的】 一、掌握文本编辑器vi的使用方法 二、了解GNU gcc编译器 三、掌握使用GCC编译C语言程序的方法 【实验内容】 一、vi的三种工作模式： 1、命令模式： 执行相关文本编辑命令 2、输入模式： 输入文本 3、末行模式： 实现查找、替换、保存、多文件操作等等功能 二、进入vi，直接在Shell提示符下键入vi [文件名称]，如果该文件在当前目录不存在，则vi创建之。 三、退出vi 1、在命令模式下输入“： wq”，保存文件并退出vi 2、若不需要保存文件，输入“： q” 3、若文件已修改，但不保存，输入“：

q！”强制退出vi 4、其它一些不常用的方法在此省略。 四、命令模式下的常用编辑命令 1、启动vi后，进入的是vi的命令模式 2、按i键，进入输入模式，可以进行文本的编辑，在输入模式下，按esc 键，可切换回命令模式 i： 光标位置不变，可在光标左侧插入正文 a： 光标位置向后退一格，可在光标左侧插入正文 o： 在光标所在行的下一行增添新行 O： 在光标所在行的上一行增添新行 I： 光标跳到当前行的开头 A： 光标跳到当前行的末尾 3、光标的移动 k、j、h、l分别等同于上、下、左、右箭头键 Ctrl+b，向上翻一页

Ctrl+f，向下翻一页 nH，将光标移到屏幕的第n行 nL，将光标移到屏幕的倒数第n行 4、删除文本 nX，删除光标所指向的后n个字符 D，删除光标右侧的所有字符（包括光标所指向的字符）db，删除光标左侧的全部字符 ndd，删除当前行和当前行以后的n行内容 5、粘贴和复制 p，将缓冲区的内容粘贴到当前字符的右侧 P，将缓冲区的内容粘贴到当前字符的左侧 yy，复制当前行到内存缓冲区 nyy，复制n行内容到内存缓冲区 6、搜索字符串 /str1，正向搜索字符串str1 n，继续搜索 ？str2，反向搜索字符串str2 7、撤销和重复 u，撤销前一条命令的执行结果 .，重复最后一条命令

第9章 预处理命令

第9章预处理命令 宏定义不是Ｃ语句，所以不能在行尾加分号。如果加了分号则会连分号一起进行臵换。 可以用#undef命令终止宏定义的作用域。 对程序中用“”括起来的内容（即字符串内的字符），即使与宏名相同，也不进行臵换。宏定义只做字符替换，不分配内存空间。 宏名不是变量，不分配存储空间，也不能对其进行赋值。 在宏展开时，预处理程序仅对宏名作简单的字符串替换，不作任何检查。 在进行宏定义时，可以引用已定义的宏名 无参宏定义的一般格式： #define 标识符字符串 将这个标识符（名字）称为“宏名”，在用预编译时将宏名替换成字符串的过程称为“宏展开”。#define是宏定义命令。 带参宏定义的一般格式： #define 宏名(形参表)字符串 带参宏的调用和宏展开： 调用格式：宏名(实参表)； 宏展开(又称为宏替换)的方法：用宏调用提供的实参直接臵换宏定义中相应的形参，非形参字符保持不变。 定义有参宏时，宏名与左圆括号之间不能留有空格。否则，Ｃ编译系统会将空格以后的所有字符均作为替代字符串，而将该宏视为无参宏。 有参宏的展开，只是将实参作为字符串，简单地臵换形参字符串，而不做任何语法检查。 为了避免出错,可以在所有形参外，甚至整个字符串外，均加上一对圆括号。 如: #define S(r) 3.14*(r)*(r) 则：area=S(a+b); 展开后为: area=3.14*(a+b)*(a+b); 调用有参函数时，是先求出实参的值，然后再复制一份给形参。而展开有参宏时，只是将实参简单地臵换形参。函数调用是在程序运行时处理的，为形参分配临时的内存单元；而宏展开则是在编译前进行的，在展开时不分配内存单元，不进行值的传递，也没有“返回值”的概念。调用函数只可得到一个返回值，而用宏可以设法得到几个结果。 在有参函数中，形参都是有类型的，所以要求实参的类型与其一致；而在有参宏中，形参和宏名都没有类型，只是一个简单的符号代表，因此，宏定义时，字符串可以是任何类型的数据。 使用宏次数多时，宏展开后源程序变长，因为每展开一次都是程序增长，而函数调用不会使源程序变长。 宏替换不占用运行时间，只占编译时间。而函数调用则占用运行时间（分配单元、保留现场、值传递、返回）。 在程序中如果有带实参的宏，则按#define命令行中指定的字符串从左到右进行臵换。如果字符串中包含宏中的形参，则将程序语句中相应的实参（可以是常量、变量或表达式）代替形参。如果宏定义中的字符串中的字符不是参数字符，则保留。

linux系统下C编译器GCC入门

linux系统下C编译器— gcc 入门 <一>gcc简介 Linux系统下的gcc（GNU C Compiler）是GNU推出的功能强大、性能优越的多平台编译器，是GNU的代表作品之一。gcc是可以在多种硬体平台上编译出可执行程序的超级编译器，其执行效率与一般的编译器相比平均效率要高20%~30%。gcc编译器能将C、C++语言源程序、汇程式化序和目标程序编译、连接成可执行文件，如果没有给出可执行文件的名字，gcc将生成一个名为 a.out的文件。在Linux系统中，可执行文件没有统一的后缀，系统从文件的属性来区分可执行文件和不可执行文件。而gcc则通过后缀来区别输入文件的类别，下面我们来介绍gcc所遵循的部分约定规则。 .c为后缀的文件，C语言源代码文件； .a为后缀的文件，是由目标文件构成的档案库文件； .C，.cc或.cxx 为后缀的文件，是C++源代码文件； .h为后缀的文件，是程序所包含的头文件； .i 为后缀的文件，是已经预处理过的C源代码文件； .ii为后缀的文件，是已经预处理过的C++源代码文件； .m为后缀的文件，是Objective-C源代码文件； .o为后缀的文件，是编译后的目标文件； .s为后缀的文件，是汇编语言源代码文件； .S为后缀的文件，是经过预编译的汇编语言源代码文件。 <二>gcc的执行过程 虽然我们称gcc是C语言的编译器，但使用gcc由C语言源代码文件生成可执行文件的过程不仅仅是编译的过程，而是要经历四个相互关联的步骤∶预处理(也称预编译，Preprocessing)、编译(Compilation)、汇编(Assembly)和连接(Linking)。命令gcc首先调用cpp进行预处理，在预处理过程中，对源代码文件中的文件包含(include)、预编译语句(如宏定义define等)进行分析。接着调用cc1进行编译，这个阶段根据输入文件生成以.o为后缀的目标文件。汇编过程是针对汇编语言的步骤，调用as进行工作，一般来讲，. S为后缀的汇编语言源代码文件和汇编，.s为后缀的汇编语言文件经过预编译和汇编之后都生成以.o为后缀的目标文件。当所有的目标文件都生成之后，gcc就调用ld来完成最后的关键性工作，这个阶段就是连接。在连接阶段，所有的目标文件被安排在可执行程序中的恰当的位置，同时，该程序所调用到的库函数也从各自所在的档案库中连到合适的地方。 <三>gcc的基本用法和选项 在使用gcc编译器的时候，我们必须给出一系列必要的调用参数和文件名称。g cc编译器的调用参数大约有100多个，其中多数参数我们可能根本就用不到，这里只介绍其中最基本、最常用的参数。

C#中的预处理指令

3.9.1排除和包含代码 或许最常用的预处理器指令就是用于控制什么时候以及如何包含代码的指令。举个例子来说，要使代码能够同时由C# 2.0和之前的C# 1.2版本编译器进行编译，可以使用一个预处理器指令，在遇到1.2编译器的时候，就排除C# 2.0特有的代码。我们的tic-tac-toe例子和代码清单 3-52对此进行了演示。 代码清单3-52遇到C# 1.x编译器的时候排除C# 2.0代码

在这个例子中，调用了System.Console.Clear()方法，这是只有2.0 CLI才支持的方法。使用#if和#endif预处理器指令，这一行代码就只有在定义了预处理器符号CSHARP2的前提下才会编译。 预处理器指令的另一个应用是适应不同平台之间的差异，比如用WINDOWS和LINUX #if指令将Windows和Linux特有的API包围起来。开发者经常用这些指令来取代多行注释 （/*...*/），因为它们更容易通过定义恰当的符号或者通过一次搜索/替换来移除。预处理器指令最后一个常见的用途是调试。如果用一个#if DEBUG指令将调试代码包围起来，那么在大多数IDE中，都能在最终的发布版本中移除这些代码。IDE默认将DEBUG符号用于调试编译，将RELEASE符号用于发布版本。 为了处理else-if条件，可以在#if指令中使用#elif指令，而不是创建两个完全独立的#if块，如代码清单3-53所示。 代码清单3-53使用#if、#elif和#endif指令 #if LINUX ... #elif WINDOWS ... #endif 输出3-28展示了在使用Mono编译器的前提下，如何实现相同的功能。

#pragma指令用法汇总和解析

#pragma指令用法汇总和解析 一. message 参数。 message 它能够在编译信息输出窗 口中输出相应的信息，这对于源代码信息的控制是非常重要的。其使用方法为： #pragma message(“消息文本”) 当编译器遇到这条指令时就在编译输出窗口中将消息文本打印出来。 当我们在程序中定义了许多宏来控制源代码版本的时候，我们自己有可能都会忘记有没有正确的设置这些宏，此时我们可以用这条 指令在编译的时候就进行检查。假设我们希望判断自己有没有在源代码的什么地方定义了_X86这个宏可以用下面的方法 #ifdef _X86 #pragma message(“_X86 macro activated!”) #endif 当我们定义了_X86这个宏以后，应用程序在编译时就会在编译输出窗口里显示“_ X86 macro activated!”。我们就不会因为不记得自己定义的一些特定的宏而抓耳挠腮了 二. 另一个使用得比较多的#pragma参数是code_seg。格式如： #pragma code_seg( [ [ { push | pop}, ] [ identifier, ] ] [ "segment-name" [, "segment-class" ] ) 该指令用来指定函数在.obj文件中存放的节,观察OBJ文件可以使用VC自带的dumpbin命令行程序,函数在.obj文件中默认的存放节 为.text节 如果code_seg没有带参数的话,则函数存放在.text节中 push (可选参数) 将一个记录放到内部编译器的堆栈中,可选参数可以为一个标识符或者节名 pop(可选参数) 将一个记录从堆栈顶端弹出,该记录可以为一个标识符或者节名 identifier (可选参数) 当使用push指令时,为压入堆栈的记录指派的一个标识符,当该标识符被删除的时候和其相关的堆栈中的记录将被弹出堆栈 "segment-name" (可选参数) 表示函数存放的节名 例如: //默认情况下,函数被存放在.text节中 void func1() { // stored in .text } //将函数存放在.my_data1节中 #pragma code_seg(".my_data1") void func2() { // stored in my_data1 } //r1为标识符,将函数放入.my_data2节中 #pragma code_seg(push, r1, ".my_data2") void func3() { // stored in my_data2 } int main() { } 三. #pragma once (比较常用） 这是一个比较常用的指令,只要在头文件的最开始加入这条指令就能够保证头文件被编译一次 四. #pragma hdrstop表示预编译头文件到此为止，后面的头文件不进行预编译。

arm-linux-gcc 常用参数讲解 gcc编译器使用方法

arm-linux-gcc常用参数讲解gcc编译器使用方法 我们需要编译出运行在ARM平台上的代码，所使用的交叉编译器为arm-linux-gcc。下面将arm-linux-gcc编译工具的一些常用命令参数介绍给大家。 在此之前首先介绍下编译器的工作过程，在使用GCC编译程序时，编译过程分为四个阶段： 1. 预处理（Pre-Processing） 2. 编译（Compiling） 3. 汇编（Assembling） 4. 链接（Linking） Linux程序员可以根据自己的需要让GCC在编译的任何阶段结束，以便检查或使用编译器在该阶段的输出信息，或者对最后生成的二进制文件进行控制，以便通过加入不同数量和种类的调试代码来为今后的调试做好准备。和其它常用的编译器一样，GCC也提供了灵活而强大的代码优化功能，利用它可以生成执行效率更高的代码。 以文件example.c为例说明它的用法 0. arm-linux-gcc -o example example.c 不加-c、-S、-E参数，编译器将执行预处理、编译、汇编、连接操作直接生成可执行代码。 -o参数用于指定输出的文件，输出文件名为example,如果不指定输出文件，则默认输出 a.out 1. arm-linux-gcc -c -o example.oexample.c -c参数将对源程序example.c进行预处理、编译、汇编操作，生成example.0文件 去掉指定输出选项"-o example.o"自动输出为example.o,所以说在这里-o加不加都可以 2.arm-linux-gcc -S -o example.sexample.c -S参数将对源程序example.c进行预处理、编译，生成example.s文件 -o选项同上 3.arm-linux-gcc -E -o example.iexample.c -E参数将对源程序example.c进行预处理，生成example.i文件（不同版本不一样，有的将预处理后的内容打印到屏幕上） 就是将#include，#define等进行文件插入及宏扩展等操作。 4.arm-linux-gcc -v -o example example.c 加上-v参数，显示编译时的详细信息，编译器的版本，编译过程等。 5.arm-linux-gcc -g -o example example.c -g选项，加入GDB能够使用的调试信息,使用GDB调试时比较方便。 6.arm-linux-gcc -Wall -o example example.c -Wall选项打开了所有需要注意的警告信息，像在声明之前就使用的函数，声明后却没有使用的变量等。 7.arm-linux-gcc -Ox -o example example.c -Ox使用优化选项，X的值为空、0、1、2、3 0为不优化，优化的目的是减少代码空间和提高执行效率等，但相应的编译过程时间将较长并占用较大的内存空间。 8.arm-linux-gcc -I /home/include -o example example.c -Idirname: 将dirname所指出的目录加入到程序头文件目录列表中。如果在预设系统及当前目录中没有找到需要的文件，就到指定的dirname目录中去寻找。 9.arm-linux-gcc -L /home/lib -o example example.c

c语言预处理命令之条件编译(ifdefelseendifif等)

C语言预处理命令之条件编译（#ifdef,#else,#endif,#if等） 预处理过程扫描源代码，对其进行初步的转换，产生新的源代码提供给编译器。可见预处理过程先于编译器对源代码进行处理。 在C语言中，并没有任何内在的机制来完成如下一些功能：在编译时包含其他源文件、定义宏、根据条件决定编译时是否包含某些代码。要完成这些工作，就需要使用预处理程序。尽管在目前绝大多数编译器都包含了预处理程序，但通常认为它们是独立于编译器的。预处理过程读入源代码，检查包含预处理指令的语句和宏定义，并对源代码进行响应的转换。预处理过程还会删除程序中的注释和多余的空白字符。 预处理指令是以#号开头的代码行。#号必须是该行除了任何空白字符外的第一个字符。#后是指令关键字，在关键字和#号之间允许存在任意个数的空白字符。整行语句构成了一条预处理指令，该指令将在编译器进行编译之前对源代码做某些转换。下面是部分预处理指令： 指令用途 #空指令，无任何效果 #include包含一个源代码文件 #define定义宏 #undef取消已定义的宏 #if如果给定条件为真，则编译下面代码 #ifdef如果宏已经定义，则编译下面代码 #ifndef如果宏没有定义，则编译下面代码 #elif如果前面的#if给定条件不为真，当前条件为真，则编译下面代码 #endif结束一个#if……#else条件编译块 #error停止编译并显示错误信息 一、文件包含 #include预处理指令的作用是在指令处展开被包含的文件。包含可以是多重的，也就是说一个被包含的文件中还可以包含其他文件。标准C编译器至少支持八重嵌套包含。

预处理过程不检查在转换单元中是否已经包含了某个文件并阻止对它的多次包含。这样就可以在多次包含同一个头文件时，通过给定编译时的条件来达到不同的效果。例如： #defineAAA #include"t.c" #undefAAA #include"t.c" 为了避免那些只能包含一次的头文件被多次包含，可以在头文件中用编译时条件来进行控制。例如： /*my.h*/ #ifndefMY_H #defineMY_H …… #endif 在程序中包含头文件有两种格式： #include #include"my.h" 第一种方法是用尖括号把头文件括起来。这种格式告诉预处理程序在编译器自带的或外部库的头文件中搜索被包含的头文件。第二种方法是用双引号把头文件括起来。这种格式告诉预处理程序在当前被编译的应用程序的源代码文件中搜索被包含的头文件，如果找不到，再搜索编译器自带的头文件。 采用两种不同包含格式的理由在于，编译器是安装在公共子目录下的，而被编译的应用程序是在它们自己的私有子目录下的。一个应用程序既包含编译器提供的公共头文件，也包含自定义的私有头文件。采用两种不同的包含格式使得编译器能够在很多头文件中区别出一组公共的头文件。

多文件结构和编译预处理命令

多文件结构和编译预处理命令 C++完整的源程序一般由三部分构成：类的定义，类成员的实现，主函数 在较大的项目中，常需要多个源文件（即多个编译单元），c++要求一个类的定义必须在使用该类的编译单元中。因此，把类的定义写在头文件中。 （重点）一个项目至少分三个文件：类定义文件（.h）、类实现文件（.cpp）、类的使用文件（.cpp） （重点）对于复杂的程序：每个类都有单独的类定义和类实现。这样做的好处：可以对不同的文件进行单独编写、编译，最后链接，同时利用类的封 装性，在程序的调试和修改时只对其中某一个类的定义和实现修改，其余保持不动。 预处理指令声明中出现的注释以及一行单独一个#符号的情况在预编译处理过程中都会被 忽略掉。 宏定义在c++中依然使用，但最好的方式是在类型说明语句中用const修饰来取代宏定义。（重点）大型程序中，往往需要使用很多头文件，因此要发现重复包含并不容易。要解决这个问题，我们可以在头文件使用条件编译。（三种方式） 表1是所有预处理指令和意义 指令意义 #define 定义宏 #undef 取消定义宏 #include 包含文件 #ifdef 其后的宏已定义时激活条件编译块 #ifndef 其后的宏未定义时激活条件编译块 #endif 中止条件编译块 #if 其后表达式非零时激活条件编译块 #else 对应#ifdef, #ifndef, 或#if 指令 #elif #else 和#if的结合 #line 改变当前行号或者文件名 #error 输出一条错误信息 #pragma 为编译程序提供非常规的控制流信息 宏定义 #define指令定义宏，宏定义可分为两类：简单宏定义，带参数宏定义。 简单宏定义有如下一般形式： #define 名字替换文本 它指示预处理器将源文件中所有出现名字记号的地方都替换为替换文本，替换文本可以是任

C51几个预编译指令的用法

C51几个预编译指令的用法 标签: 指令用法编译2009-07-31 10:47 预处理过程扫描源代码，对其进行初步的转换，产生新的源代码提供给编译器。可见预处理过程先于编译器对源代码进行处理。 在C语言中，并没有任何内在的机制来完成如下一些功能： 在编译时包含其他源文件、定义宏、根据条件决定编译时是否包含某些代码。要完成这些工作，就需要使用预处理程序。尽管在目前绝大多数编译器都包含了预处理程序，但通常认为它们是独立于编译器的。预处理过程读入源代码，检查包含预处理指令的语句和宏定义，并对源代码进行响应的转换。预处理过程还会删除程序中的注释和多余的空白字符。 预处理指令是以#号开头的代码行。#号必须是该行除了任何空白字符外的第一个字符。#后是指令关键字，在关键字和#号之间允许存在任意个数的空白字符。整行语句构成了一条预处理指令，该指令将在编译器进行编译之前对源代码做某些转换。下面是部分预处理指令： 指令用途 #空指令，无任何效果 #include包含一个源代码文件 #define定义宏 #undef取消已定义的宏 #if如果给定条件为真，则编译下面代码 #ifdef如果宏已经定义，则编译下面代码 #ifndef如果宏没有定义，则编译下面代码

#elif如果前面的#if给定条件不为真，当前条件为真，则编译下面代码 #endif结束一个#if……#else条件编译块 #error停止编译并显示错误信息 一、文件包含 #include预处理指令的作用是在指令处展开被包含的文件。包含可以是多重的，也就是说一个被包含的文件中还可以包含其他文件。标准C编译器至少支持八重嵌套包含。 预处理过程不检查在转换单元中是否已经包含了某个文件并阻止对它的多次包含。这样就可以在多次包含同一个头文件时，通过给定编译时的条件来达到不同的效果。例如： #define AAA #include "t.c" #undef AAA #include "t.c" 为了避免那些只能包含一次的头文件被多次包含，可以在头文件中用编译时条件来进行控制。例如： #ifndef MY_H #define MY_H …… #endif 在程序中包含头文件有两种格式： #include #include "my.h"

gcc编译器 CFLAGS 标志参数说明

gcc编译器 CFLAGS 标志参数说明2012-11-14 15:10:28 分类：LINUX CFLAGS = -g -O2 -Wall -Werror -Wno-unused 编译出现警告性错误unused-but-set-variable，变量定义但没有使用，解决方法: 增加CFLAGS 或CPPFLAGS参数如下： CPPFLAGS=" -Werror -Wno-unused-but-set-variable" || exit 1 Gcc总体选项列表 后缀名所对应的语言 -S只是编译不汇编，生成汇编代码 -E只进行预编译，不做其他处理 -g在可执行程序中包含标准调试信息 -o file把输出文件输出到file里 -v打印出编译器内部编译各过程的命令行信息和编译器的版本 -I dir在头文件的搜索路径列表中添加dir目录 -L dir在库文件的搜索路径列表中添加dir目录 -static链接静态库 -llibrary连接名为library的库文件 ·“-I dir” 正如上表中所述，“-I dir”选项可以在头文件的搜索路径列表中添加dir目录。由于Linux 中头文件都默认放到了“/usr/include/”目录下，因此，当用户希望添加放置在其他位置的头文件时，就可以通过“-I dir”选项来指定，这样，Gcc就会到相应的位置查找对应的目录。 比如在“/root/workplace/Gcc”下有两个文件： #include int main() { printf(“Hello!!\n”); return 0; } #include

这样，就可在Gcc命令行中加入“-I”选项： [root@localhost Gcc] Gcc hello1.c –I /root/workplace/Gcc/ -o hello1 这样，Gcc就能够执行出正确结果。 小知识 在include语句中，“<>”表示在标准路径中搜索头文件，““”” 表示在本目录中搜索。故在上例中，可把hello1.c的“#include” 改为“#include “my.h””，就不需要加上“-I”选项了。 ·“-L dir” 选项“-L dir”的功能与“-I dir”类似，能够在库文件的搜索路径列表中添加dir目录。 例如有程序hello_sq.c需要用到目录“/root/workplace/Gcc/lib”下的一个动态库 libsunq.so，则只需键入如下命令即可： [root@localhost Gcc] Gcc hello_sq.c –L /root/workplace/Gcc/lib –lsunq –o hello_sq 需要注意的是，“-I dir”和“-L dir”都只是指定了路径，而没有指定文件，因此不能在 路径中包含文件名。 另外值得详细解释一下的是“-l”选项，它指示Gcc去连接库文件libsunq.so。由于在Linux 下的库文件命名时有一个规定：必须以lib三个字母开头。因此在用-l选项指定链接的库 文件名时可以省去lib三个字母。也就是说Gcc在对”-lsunq”进行处理时，会自动去链接 名为 libsunq.so的文件。 （2）告警和出错选项 Gcc的告警和出错选项如表3.8所示。 Gcc总体选项列表 选项含义 -ansi 支持符合ANSI标准的C程序 -pedantic 允许发出ANSI C标准所列的全部警告信息 -pedantic-error 允许发出ANSI C标准所列的全部错误信息 -w 关闭所有告警 -Wall 允许发出Gcc提供的所有有用的报警信息 -werror 把所有的告警信息转化为错误信息，并在告警发生时终止编译过程 下面结合实例对这几个告警和出错选项进行简单的讲解。 如有以下程序段： #include void main() { long long tmp = 1; printf(“This is a bad code!\n”);

C51几个预编译指令的用法

C51几个预编译指令的用法 标签: 指令用法编译2009-07-31 10:47 预处理过程扫描源代码，对其进行初步的转换，产生新的源代码提供给编译器。可见预处理过程先于编译器对源代码进行处理。 在C语言中，并没有任何内在的机制来完成如下一些功能：在编译时包含其他源文件、定义宏、根据条件决定编译时是否包含某些代码。要完成这些工作，就需要使用预处理程序。尽管在目前绝大多数编译器都包含了预处理程序，但通常认为它们是独立于编译器的。预处理过程读入源代码，检查包含预处理指令的语句和宏定义，并对源代码进行响应的转换。预处理过程还会删除程序中的注释和多余的空白字符。 预处理指令是以#号开头的代码行。#号必须是该行除了任何空白字符外的第一个字符。#后是指令关键字，在关键字和#号之间允许存在任意个数的空白字符。整行语句构成了一条预处理指令，该指令将在编译器进行编译之前对源代码做某些转换。下面是部分预处理指令： 指令用途 #空指令，无任何效果 #include包含一个源代码文件 #define定义宏 #undef取消已定义的宏 #if如果给定条件为真，则编译下面代码 #ifdef如果宏已经定义，则编译下面代码 #ifndef如果宏没有定义，则编译下面代码 #elif如果前面的#if给定条件不为真，当前条件为真，则编译下面代码 #endif结束一个#if……#else条件编译块 #error停止编译并显示错误信息 一、文件包含 #include预处理指令的作用是在指令处展开被包含的文件。包含可以是多重的，也就是说一个被包含的文件中还可以包含其他文件。标准C编译器至少支持八重嵌套包含。 预处理过程不检查在转换单元中是否已经包含了某个文件并阻止对它的多次包含。这样就可以在多次包含同一个头文件时，通过给定编译时的条件来达到不同的效果。例如： #define AAA

预编译#define #ifdef #endif用法

预编译#define #ifdef #endif用法 2010-08-05 10:08 最近在看Linux底层代码，发现好多代码里有#define #ifdef #endif，找了个介绍详细的文章，供大家参考： #ifdef的用法 灵活使用#ifdef指示符，我们可以区隔一些与特定头文件、程序库和其他文件版本有关的代码。 代码举例：新建define.cpp文件 ＃include “iostream.h” int main() { #ifdef DEBUG cout<< “Beginning execution of main()”; #endif return 0; } 运行结果为：Press any key to continue 改写代码如下： ＃include “iostream.h” #define DEBUG int main() { #ifdef DEBUG cout<< “Beginning execution of main()”; #endif return 0; } 运行结果为：Beginning execution of main() Press any key to continue更一般的情况是，#define 语句是包含在一个特定的头文件中。 比如，新建头文件head.h，在文件中加入代码： #ifndef DEBUG #define DEBUG #endif 而在define.cpp源文件中，代码修改如下： ＃include “iostream.h” ＃include “head.h” int main(){ #ifdef DEBUG

cout<< “Beginning execution of main()”; #endif return 0; } 运行结果如下：Beginning execution of main() Press any key to continue 结论：通过使用#ifdef指示符，我们可以区隔一些与特定头文件、程序库和其他文件版本有关的代码。 “#ifdef”的运用magicchip 发表于 2007-8-16 9:10:00 “#ifdef”在C++中运用 常常在建立header file的时候需要先写一段文字 比如下面这段话 #ifdef HEADERFILENAME_H #define HEADERFILENAME_H class ClassName { … }; #endif 那段#ifdef有必要写吗? 其实有些无写都不会影响代码的Runtime 不过对运行速度和文件大小有一定的影响 大概很多人很喜欢用＃i nclude来抓取文件吧 炎也很喜欢 总是在main.cpp中include一次 然后又在classfile.cpp中又使用一次