预编译指令

Ⅰ C语言预编译命令

#include <assert.h> //设定插入点
#include <ctype.h> //字符处理
#include <errno.h> //定义错误码
#include <float.h> //浮点数处理
#include <fstream.h> //文件输入／输出
#include <iomanip.h> //参数化输入／输出
#include <iostream.h> //数据流输入／输出
#include <limits.h> //定义各种数据类型最值常量
#include <locale.h> //定义本地化函数
#include <math.h> //定义数学函数
#include <stdio.h> //定义输入／输出函数
#include <stdlib.h> //定义杂项函数及内存分配函数
#include <string.h> //字符串处理
#include <strstrea.h> //基于数组的输入／输出
#include <time.h> //定义关于时间的函数
#include <wchar.h> //宽字符处理及输入／输出
#include <wctype.h> //宽字符分类

//////////////////////////////////////////////////////////////////////////

标准 C++ （同上的不再注释）

#include <algorithm> //STL 通用算法
#include <bitset> //STL 位集容器
#include <cctype>
#include <cerrno>
#include <clocale>
#include <cmath>
#include <complex> //复数类
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque> //STL 双端队列容器
#include <exception> //异常处理类
#include <fstream>
#include <functional> //STL 定义运算函数（代替运算符）
#include <limits>
#include <list> //STL 线性列表容器
#include <map> //STL 映射容器
#include <iomanip>
#include <ios> //基本输入／输出支持
#include <iosfwd> //输入／输出系统使用的前置声明
#include <iostream>
#include <istream> //基本输入流
#include <ostream> //基本输出流
#include <queue> //STL 队列容器
#include <set> //STL 集合容器
#include <sstream> //基于字符串的流
#include <stack> //STL 堆栈容器
#include <stdexcept> //标准异常类
#include <streambuf> //底层输入／输出支持
#include <string> //字符串类
#include <utility> //STL 通用模板类
#include <vector> //STL 动态数组容器
#include <cwchar>
#include <cwctype>

using namespace std;

//////////////////////////////////////////////////////////////////////////

C99 增加

#include <complex.h> //复数处理
#include <fenv.h> //浮点环境
#include <inttypes.h> //整数格式转换
#include <stdbool.h> //布尔环境
#include <stdint.h> //整型环境
#include <tgmath.h> //通用类型数学宏

Ⅱ 编译和预编译有什么区别。

预编译又称为预处理，是做些代码文本的替换工作。

处理#开头的指令，比如拷贝#include包含的文件代码，#define宏定义的替换,条件编译等

就是为编译做的预备工作的阶段

主要处理#开始的预编译指令
编译(compilation , compile) 1、利用编译程序从源语言编写的源程序产生目标程序的过程。 2、用编译程序产生目标程序的动作。 编译就是把高级语言变成计算机可以识别的2进制语言，计算机只认识1和0，编译程序把人们熟悉的语言换成2进制的。

Ⅲ C语言提供的预编译处理命令主要有哪三种

几个预编译指令的用法
预处理过程扫描源代码，对其进行初步的转换，产生新的源代码提供给编译器。可见预处理过程先于编译器对源代码进行处理。
在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
<my.h>
#include
"my.h"
第一种方法是用尖括号把头文件括起来。这种格式告诉预处理程序在编译器自带的或外部库的头文件中搜索被包含的头文件。第二种方法是用双引号把头文件括起来。这种格式告诉预处理程序在当前被编译的应用程序的源代码文件中搜索被包含的头文件，如果找不到，再搜索编译器自带的头文件。
采用两种不同包含格式的理由在于，编译器是安装在公共子目录下的，而被编译的应用程序是在它们自己的私有子目录下的。一个应用程序既包含编译器提供的公共头文件，也包含自定义的私有头文件。采用两种不同的包含格式使得编译器能够在很多头文件中区别出一组公共的头文件。
二、宏
宏定义了一个代表特定内容的标识符。预处理过程会把源代码中出现的宏标识符替换成宏定义时的值。宏最常见的用法是定义代表某个值的全局符号。宏的第二种用法是定义带参数的宏，这样的宏可以象函数一样被调用，但它是在调用语句处展开宏，并用调用时的实际参数来代替定义中的形式参数。
1.#define指令
#define预处理指令是用来定义宏的。该指令最简单的格式是：首先神明一个标识符，然后给出这个标识符代表的代码。在后面的源代码中，就用这些代码来替代该标识符。这种宏把程序中要用到的一些全局值提取出来，赋给一些记忆标识符。
#define
MAX_NUM
10
int
array[MAX_NUM];
for(i=0;i<MAX_NUM;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指令没有正式的定义。编译器可以自定义其用途。典型的用法是禁止或允许某些烦人的警告信息。

Ⅳ sizeof操作符可以用于 #if 预编译指令中吗

不可以，因为预编译在编译过程的早期进行, 此时尚未对类型名称进行分析。作为替代, 可以考虑使用ANSI 的<limits.h> 中定义的常量, 或者使用“配置”(configure) 脚本。更好的办法是, 书写与类型大小无关的代码。
操作符是指令系统的每一条指令都有一个操作符，它表示该指令应进行什么性质的操作。不同的指令用操作符这个字段的不同编码来表示，每一种编码代表一种指令。组成操作符字段的位数一般取决于计算机指令系统的规模。
编译(compilation , compile) 1、利用编译程序从源语言编写的源程序产生目标程序的过程。 2、用编译程序产生目标程序的动作。 编译就是把高级语言变成计算机可以识别的2进制语言，计算机只认识1和0，编译程序把人们熟悉的语言换成2进制的。编译程序把一个源程序翻译成目标程序的工作过程分为五个阶段：词法分析；语法分析；语义检查和中间代码生成；代码优化；目标代码生成。主要是进行词法分析和语法分析，又称为源程序分析，分析过程中发现有语法错误，给出提示信息。

Ⅳ 什么是预编译，请举例说明使用方法

主要是对代码做编译前的处理
主要处理#开始的预编译指令
比如 #include #define指令 这种的 就是把包引入或者定义引入
也就是在编译的时候，代码已经没有二义性、包含关系等这种麻烦了。

Ⅵ 预编译命令都有哪些

一、预编译命令具体什么意思？
答：预编译命令是由ANSI C统一规定的，但是它不是C语言的组成部分，不能直接对它们进行编译。必须在对程序进行通常的编（包括词法和语法分析，代码生成，优化等）之前，先对程序中这些特殊的命令进行“预处理”，你慢慢悟，我小学生文化都看懂皮毛了，我不信你不知道它的意思。
二、#include <stdio.h>什么意思？
答：把stdio.h这个文件包含进来，至于stdio.h是什么，你自己慢慢看。

三、 void main()这个是什么意思？？
答：加void 表示无类型，
我们知道main()是系统调用的，
那么在main()前面加 void就保证系统不使用main()函数带回的任何值。

Ⅶ 自定义C# 预编译指令没生效

不是配置管理器中设置的。在菜单《项目》-->《****属性》中选择《生成》标签页，在条件编译符号中填写‘LocalDebug’

Ⅷ 什么是预编译，何时需要预编译

预编译又称为预处理，是做些代码文本的替换工作

预编译又称为预处理,是做些代码文本的替换工作

处理#开头的指令,比如拷贝#include包含的文件代码，#define宏定义的替换,条件编译等

就是为编译做的预备工作的阶段

主要处理#开始的预编译指令

预编译指令指示了在程序正式编译前就由编译器进行的操作，可以放在程序中的任何位置。常见的预编译指令有：

(1)#include 指令

该指令指示编译器将xxx.xxx文件的全部内容插入此处。若用<>括起文件则在系统的INCLUDE目录中寻找文件，若用" "括起文件则在当前目录中寻找文件。一般来说，该文件是后缀名为"h"或"cpp"的头文件。

注意：<>不会在当前目录下搜索头文件，如果我们不用<>而用""把头文件名扩起，其意义为在先在当前目录下搜索头文件，再在系统默认目录下搜索。

(2)#define指令

该指令有三种用法:

第一种是定义标识，标识有效范围为整个程序，形如#define XXX，常与#if配合使用；

第二种是定义常数，如#define max 100，则max代表100（这种情况下使用const定义常数更好，原因见注1）；

第三种是定义"函数"，如#define get_max(a, b) ((a)>(b)?(a):(b)) 则以后使用get_max(x,y)就可以得到x和y中较大的数（这种方法存在一些弊病，见注2）。

第四种是定义"宏函数"，如#define GEN_FUN(type) type max_##type(type a,type b){return a>b?a:b;} ，使用时，用GEN_FUN(int)，则此处预编译后就变成了 max_int(int a,int b){return a>b?a:b;},以后就可以使用max_int(x,y)就可以得到x和y中较大的数.比第三种，增加了类型的说明。

(3)#if、#else和#endif指令

这些指令一般这样配合使用：

#if defined(标识) //如果定义了标识

要执行的指令

#else

要执行的指令

#endif

在头文件中为了避免重复调用(比如说两个头文件互相包含对方)，常采用这样的结构：

#if !(defined XXX) //XXX为一个在你的程序中唯一的标识符，

//每个头文件的标识符都不应相同。

//起标识符的常见方法是若头文件名为"abc.h"

//则标识为"abc_h"

#define XXX

真正的内容，如函数声明之类

#endif

Ⅸ 预编译命令行由什么符号开头

#include "stdio.h"
#define P 3
void *F(int x)/*定义一个无类型函数，它有返回值，只是返回的值是指向无类型数据的指针*/

void main(){printf("%d\n",(int)F(1+3));/*将无类型函数F返回的指针值通过(int)强制转换为int型*/

还有几个问题，
1.预处理命令行必须位于源文件的开头是对是错？为什么？
对！
编译器在编译源代码时都是从开头到结尾依次读取，自己定义的变量、宏等等都得放前面，这样在编译器在读到它们时就作一个记录；
在使用这些变量、宏时，编译器会在记录中去寻找，如果找不到就会报错——此变量未被定义。

函数可以放在结尾（main()之后），但是必须在开头作一个函数声明（也叫函数原型）以使编译器为它作记录，以便以后使用它时可以在记录中找到它。
函数也可以放在前面（main()之前），此时就不用再声明了，编译器在读到它时也会作一个记录。

总之，自己定义的东西都得先声明后使用，否则使用时在记录中会找不到它。

预处理命令也是自己定义的东西，同属这一范畴。

2.为什么在源文件的一行上不能有多条预处理命令？
每条C语句都有一个“;”作结尾，即使都放一行，编译器都能分辨得出。
预处理命令并不以“#”作为结尾标记，放一行的话编译器是无法分辨的，它会把此行作为一个语句处理

通常的语句最好都分行写，否则程序量大时是不便排错的。

3.若有下列说明和定义
union dt
date;
变量data所占内存字节数与成员c所占字节数相同，为什么？

联合体的长度是其最长成员（如double c)的长度。
联合体在内存中的存储形式：
联合体所有成员a,b,c都是同一地址，也就是说他们共同占用这一段内存。
以TC3.0为例，a占这一段内存的头2个字节，b占这一段内存的头一个字节，c占这一段内存的全部字节（也就是头4个字节）

4.为什么以下不对
char *sp;*sp="right!";
char s[10];s="right!";
一、进行字符串赋值时可以在定义时：直接在字符串定义后接“="right"”
如：char *sp="right";
或者 char s[10]="right";

二、也可以在非定义时，这时左值必须是左值必须是字符串指针变量。
如：sp="right!";
以下都是错误用法：
*sp="right!";//左值不是字符串指针变量
s="right!";//左值只是字符串指针 常量

1、如果说*a包含（x和\0)，而*b包含（x和y），拿*a-*b会得出什么结果,*a和*b都是char型变量的话

最终的表达式*a-*b中，a points to '\0',b points to 'y',so 表达式*a-*b代表的是'\0'-'y',结果是-121（y的ASCII是121）

point(char*p)
main()
{
char b[4]={'a','b','c','d'),*p=b;
point(p); printf("%c\n",*p);
}
A.a B.b C.c D.d
选哪个？为什么？

选D，p最初是首地址b，然后p是b+3,此时*p相当*(b+3)、b[3].

2号问题：
main()
,,,},i,j;
for(i=0;i<4;i++)
{for (j=0;j<i,j++)
printf("%4c",' ');/*原题就是'和'之间只有个空格,我也不清楚是怎么回事*/
for(j=__;j<4;j++)
printf(%4d",num[i][j]);
printf("\n");
}
}
printf("%4c",' '); 其中的' '其实是一个空格字符常量，这个同'a','b','c'等字符常量是一样的。
这个语句中%4c是指要读取一个字符（这个字符就是后面的空格字符常量' '）并输出，这个字符在显示器上应该占4格。所以此句的功能是输出4个空格（空格也是属于字符）。
你改成printf("%4c",'a');printf("%4c",'b');试下，它是输出3个空格和一个字符。
printf("%8c",' ');是输出8个空格，这个比printf(" ");来实现输出8个字符来得方便。

若要按下列形式输出数组右上半三角（什么玩意？）。
1 2 3 4 i=0,j=i,那么j可以是0,1,2,3
6 7 8 i=1,j=i,那么j可以是1,2,3
11 12 i=2,j=i,那么j可以是2,3
16 i=3,j=i,那么j可以是3
则下划线处应填入的是?为什么？（B）
A.i-1 B.i
C.i+1 D.4-i

3号问题：
程序中若有下列说明和定义语句：
char fun(char*);
main()
{
char *s="one",a[5]=,(*fl)()=fun,ch;
......
}
下列选项中对函数的正确调用语句是？为什么？
A.(*fl)(a);
B.*fl(*s);
C.fun(&a);
D.ch=*fl( s);

选择A，根据定义char fun(char*)，形参必须是一个字符指针，"a","s"才是字符指针(char pointer)，而"*s" is char variable,"&a" is invalid.所以排除B、C

只有fun、*fl才是函数入口地址.
B.*fl(*s);相当于*(fl(*s)),错误，指针运算符只能针对指针运算，fl(*s)得到的是int，不是指针，下同。故排除B、D.
D.*fl( s);相当于*(fl( s));

4号问题
#define S(x) 4*x*x+1
main()
{
int i=6,j=8;
printf("%d",S(i+j));
getchar();
}
这个函数的输出结果是多少？怎么得的？

得到81.
因为S(i+j)经过预编译用i+j替换x后,它被展开为4*i+j*i+j+1。即（4*6+8*6+8+1）
你应该这样改：
#define S(x) 4*(x)*(x)+1
或者 printf("%d",S((i+j)));即将i+j用括号括起来(i+j),这样就在替换时用(i+j)替换x