c语言程序指令
㈠ c语言中指令和语句有什么区别
语句是由分号结束为标志，而指令是对某个动作的完成过程。一个语句可以由多个指令组成，指令是基本单位。打个比方程序中有：c=a+b,z=x*y;这里算是一个语句，只有一个分号，指令有两个，是a+b的值赋给c,另一个是x*y的值赋给z。你可这样理解。
㈡ 求大神整理c语言指令符号及用法大全。
编译指令
编译指令
说明
#include
包含另一个文件
#define
定义一个宏（macro）或是常量
#undef
取消一个宏常量的定义
#asm和#endasm
在程序中加入汇编语言的程序
#ifdef、#ifndef、#else、#endif
用于条件式的编译
注解：//—单行注解；
基本数据类型 （int,float,double,char,void）
数据类型
类型说明
长度（位）
数据长度
bit
位
1
0，1
char
字符
8
—128~127
unsigned char
无符号字符
8
0~255
signed char
有符号字符
8
—128~127
int
整型
16
—32768~32767
short int
短整型
16
—32768~32767
unsigned int
无符号整型
16
0~65535
signed int
有符号整型
16
—32768~32767
long int
长整型
32
—2147483648~2147483647
unsigned long int
无符号长整型
32
0~4294967295
signed long int
有符号长整形
32
—2147483648~2147483647
float
浮点数(实数)
32
0.175e-38~0.402e38
double
双精度浮点
32
0.175e-38~0.402e38
void
空
0
没任何数据
用户自定义数据类型格式
typedef struct{
数据类型 变量序列1;
数据类型 变量序列1;
．．．
}自定义数据类型的名称;
保留字
_at_,alien,bdata,break,bit,case,char,code,compact,const,continue,data,
default,do,double,far,else,enum,extern,float,for,goto,if,funcused,idata,int,
inline,interrupt,large,long,pdata,_priority_,reentrant,return,sbit,sfr,sfr16,
short,sigend,sizeof,small,static,struct,switchc_task_,typedef,using,union,
unsigned,void,volatile,while,xdata
常量表示法
常数
规则
范例
十进制
一般十进制格式
1234567890
二进制
开头加上0b
0b00001110
八进制
开头加上O
O0123
十六进制
开头加上0x
0xFF45
无符号整数常量
结尾加上U
30000U
长整数常量
结尾加上L
299L
无符号长整数常量
结尾加上UL
327800UL
浮点数的常量
结尾加上F
4.234F
字符常量
以单引号括起来
‘a’
字符串常量
以双引号括起来
“hello”
-----------------------------------------------------运算符-----------------------------------------------------
算术运算
运算符
说明
范例
执行结果
+
加
c=a+b；
c 等于10
—
减
d=a—b；
d 等于6
*
乘
e=a*b；
e 等于16
/
除
f=a/b；
f 等于4
%
取余数
g=a%b；
g 等于0
++
加1
c++；相当于c=c+1；
c 等于11
——
减1
d——；相当于d=d—1；
d 等于5
=
等于
a=8；
设置a等于8
+=
先相加在等于
e+=5；相当于e=e+5；
e 等于21
—=
先相减在等于
f—=5；相当于f=f—5；
f 等于—1
*=
先相乘在等于
b*=5；相当于b=b*5；
b 等于0
/=
先相除在等于
a/=5；相当于a=a/5；
a 等于1
%=
先取余数在等于
a%=5；相当于a=a%5；
a 等于3
※假设a等于8，b等于2
比较运算
运算符
说明
范例
执行结果
==
等于
a==5
F
！=
不等于
a!=5
T
<<o:p>
小于
a<5
F
>
大于
a>5
T
<=
小于等于
a<=5
F
>=
大于等于
a>=5
T
※比较运算结果是个布尔值既TRUE（真值）或FALSE（假值）。假设a等于8
逻辑运算
运算符
说明
范例
执行结果
&&
AND
(a>5)&&(a<10)
T
||
OR
(a<5)||(a>10)
F
!
NOT
!(a>10)
T
※逻辑运算结果是个布尔值既TRUE（真值）或FALSE（假值）。假设a等于8
位逻辑运算
运算符
说明
范例
执行结果
&
AND
a&0x01
a等于1
|
OR
a|0x80
a等于0x85
~
NOT
~a
a等于0xFA
^
XOR
a^0xFF
a等于0xFA
<<
左移
a<<1
a等于0x0A
>>
右移
a>>1
a等于0x0A
※假设a等于5
----------------------------------------------------控制命令---------------------------------------------------
if语句
if（条件） 语句1;
else 语句2;
例：if(d==4) d=0; //如果d等于4就设置d等于0
else d++; //否则就将d加1
if(ticks==0) { //如果ticks等于0
ticks=1000; //ticks 设置成1000
counter[0]++; //counter[0]加1
}
嵌套if语句
例：if(counter[0]==10) {
counter[1]++;
counter[0]=0;
if(counter[1]==10) {
counter[2]++;
counter[1]=0;
}
}
switch语句
switch (变量) {
case 常量1：语句1; break;
case 常量2：语句2; break;
case 常量3：语句3; break;
．．．．．．
default ; 语句n;
}
for循环
for (初值,条件,变化值) 语句;
例：for(i=0;i<10;i++) x=x+i;
for(i=1;i<10,i++)
for(j=1;j<10,j++)
printf(“%d %d”,i,j);
无穷循环：
for( ; ; );
while循环
while (条件) 语句;
例：while (ch!=!’A’) ch=getche();
无穷循环：
while(1);
do/while循环
do {
语句;
．．．
} while(条件);
例：do {
ch=getche();
} while (ch!=”A”);
goto语句
loop1:
x++;
if(x<100) goto loop1;
----------------------------------------------------指针和函数------------------------------------------------
指针的定义
数据类型 *指针变量的名字;
例： char *p;
int *x;
指针与数组
例： char filename[80];
char *p;
p=filename; //指针p存放filename的开始地址
int x[5]={1,2,3,4,5};
int *p,sum,i;
p=x; //指针p存放数组x的开始地址
for(i=0;i<5;i++)
sum=sum+p[i]; //p[i]相当于x[i]
指针的运算
1.针变量前面加上*号就是取得指针所指向位置的内容。
例：int x[5]={1,2,3,4,5};
int *p;
p=x; //指针p存放数组x的开始地址
*p=10; //相当于设置x[0]等于10
2.变量前面加上&符号，可以取得一个变量的位置。
例：int x,y;
int *p;
p=&x; //指针p存放x的地址，相当于p是指向x 的指针
*p=1; //相当于设置x等于1
3.&符号也可以加在数组的前面
例：int x[5];
int *p;
p=&x[2]; //指针p存放x[2]的地址，相当于p是指向x[2]的指针
*p=50; //相当于设置x[2]等于50
函数
函数类型 函数名称（参数序列）；
参数说明
{
函数的主体
}
例：void delay (void) { //不返回任何数据的函数
unsigned char i,j; //没有任何参数的函数
for(i=0,i<255,i++)
for(j=0,j<255,j++);
}
main()
{
...
delay(); //调用函数
}
例：unsigned char sum(unsigned chat a,unsigned chat b)
{
unsigned chat x;
check_GLCD_busyflag(); //函数中可以调用另一个函数
x=a+b;
return x; //return会返回x的数据
}
中断服务函数
void 中断服务程序的名称(void) interrupt 中断号码using 寄存器组号码
{
中断服务子程序主体
}
中断号码
#define IE0_VECTOR 0 //0x03
#define TF0_VECTOR 1 //0x0B
#define IE1_VECTOR 2 //0x13
#define TF1_VECTOR 3 //0x1B
#define SIO_VECTOR 4 //0x23
对于S51有定时器2
#define TF2_VECTOR 5 //0x2B
例：static void xint0_isr(void) interrupt IE0_VECTOR（或0） using 1
{
unsigned char i,j=0xFF;
for(i=0,i<16,i++)
{
j++;
P1=j; //将数值输出到P1口
delay_4isr();
}
}
-----------------------------------------------------汇编语言--------------------------------------------------
在C中加入汇编语言
例：void delay100us()
{
#pragma asm
mov r7,#1
more: mov r3,#48
djnz r3,$
djnz r7,more
#pragma endasm
}
----------------------------------------------------宏（macro）----------------------------------------------
宏的定义
%*define (macro名称) (macro的指令）
例：%*define (write_1) (
setb DI
serb SK
clr SK
)
#define 宏的名称 宏的指令
例：#define uchar unsigned char
C语言中的符号总结
运算符的种类C语言的运算符可分为以下几类；
1. 算术运算符
用于各类数值运算，包括加减乘除求余自增自减共七种运算
{ （ + ） ，（ - ），（* ） ，（ / ） ,（ % ），（ ++ ），（-- ）}。
2. 关系运算符
用于比较运算，包括大于（>），小于（<</span>），等于（==），大于等于（>=），
小于等于（<=），不等于（!=）共六种。
3.逻辑运算符
用于逻辑运算，包括与(&&)或(||)非(!)三种.
4.位操作运算符
参与运算的量，按二进制位进行运算，包括：
位与（&），位或（|），位非(~),为异或（^）,左移（<<），右移(>>)共六种。
5.赋值运算符
用于赋值运算，分为：
简单赋值（=）
复合算术赋值（+=，-=,*=,/=，%=）
复合位运算赋值（&=，|=，^=，>>=，<<=）三类共十一种。
6.条件运算符
这是一个三目运算符，用于条件求值（?:）。
7.逗号运算符
用于把若干表达式组合成一个表达式（,）。
8.指针运算符
用于取内容（*）和取地址（&）两种运算。
9.求字节数运算符
用于计算数据类型所占用的字节数（sizeof）。
10.特殊运算符
有括号（），下标[],成员（→, .）
1.C的数据类型
基本类型，构造类型，指针类型，空类型
2.基本类型的分类及特点
类型说明符 字节 数值范围
字符型char 1 C字符集
基本整型int 2 -32768～32767
短整型short int 2 -32768～32767
长整型 long int 4 -214783648～214783647
无符号型 unsigned 2 0～65535
无符号长整型 unsigned long 4 0～4294967295
单精度实型 float 4 3/4E-38～3/4E+38
双精度实型 double 8 1/7E-308～1/7E+308
3.常量后缀
L或l 长整型
U或u 无符号数
F或f 浮点数
4.常量类型
整数，长整数，无符号数，浮点数，字符，字符串，符号常数，转义字符。
5.数据类型转换
a自动转换
在不同类型数据的混合运算中，由系统自动实现转换， 由少字节类型向多字节类型转换。 不同类型的量相互赋值时也由系统自动进行转换，把赋值号右边的类型转换为左边的类型。
b强制转换
由强制转换运算符完成转换。
6.运算符优先级和结合性
一般而言，单目运算符优先级较高，赋值运算符优先级低。 算术运算符优先级较高，关系和逻辑运算符优先级较低。 多数运算符具有左结合性，单目运算符、三目运算符、 赋值
7.表达式
表达式是由运算符连接常量、变量、函数所组成的式子。 每个表达式都有一个值和类型。 表达式求值按运算符的优先级和结合性所规定的顺序进行。
表示输出类型的格式字符 格式字符意义
d 以十进制形式输出带符号整数(正数不输出符号)
o 以八进制形式输出无符号整数(不输出前缀O)
x 以十六进制形式输出无符号整数(不输出前缀OX)
u 以十进制形式输出无符号整数
f 以小数形式输出单、双精度实数
e 以指数形式输出单、双精度实数
g 以%f%e中较短的输出宽度输出单、双精度实数
c 输出单个字符
s 输出字符串
标志字符为-、+、#、空格四种，其意义下表所示：
标志格式字符 标 志 意 义
- 结果左对齐，右边填空格
+ 输出符号(正号或负号)空格输出值为正时冠以空格，为负时冠以负号
# 对c，s，d，u类无影响；对o类， 在输出时加前
缀o 对x类，在输出时加前缀0x；对e,g,f 类当结果有小数时才给出小数点
格式字符串
格式字符串的一般形式为： %[*][输入数据宽度][长度]类型 其中有方括号[]的项为任选项。各项的意义如下：
1.类型
表示输入数据的类型，其格式符和意义下表所示。
格式 字符意义
d 输入十进制整数
o 输入八进制整数
x 输入十六进制整数
u 输入无符号十进制整数
f或e 输入实型数(用小数形式或指数形式)
c 输入单个字符
s 输入字符串
转义字符
转义字符是一种特殊的字符常量。转义字符以反斜线”\”开头，后跟一个或几个字符。转义字符具有特定的含义，不同于字符原有的意义，故称“转义”字符。例如，在前面各例题printf函数的格式串中用到的“\n”就是一个转义字符，其意义是“回车换行”。转义字符主要用来表示那些用一般字符不便于表示的控制代码。
常用的转义字符及其含义
转义字符 转义字符的意义
\n 回车换行
\t 横向跳到下一制表位置
\v 竖向跳格
\b 退格
\r 回车
\f 走纸换页
\\ 反斜线符”\”
\’ 单引号符
\a 鸣铃
\ddd 1～3位八进制数所代表的字符
\xhh 1～2位十六进制数所代表的字符
广义地讲，C语言字符集中的任何一个字符均可用转义字符来表示。表2.2中的\ddd和\xhh正是为此而提出的。ddd和hh分别为八进制和十六进制的ASCII代码。如\101表示字?quot;A” ，\102表示字母”B”，\134表示反斜线，\XOA表示换行等。转义字符的使用
在C语言中，对变量的存储类型说明有以下四种：
auto 自动变量
register 寄存器变量
extern 外部变量
static 静态变量
自动变量和寄存器变量属于动态存储方式， 外部变量和静态变量属于静态存储方式。在介绍了变量的存储类型之后， 可以知道对一个变量的说明不仅应说明其数据类型，还应说明其存储类型。 因此变量说明的完整形式应为： 存储类型说明符 数据类型说明符 变量名，变量名…； 例如：
static int a,b; 说明a,b为静态类型变量
auto char c1,c2; 说明c1,c2为自动字符变量
static int a[5]={1,2,3,4,5}; 说明a为静整型数组
extern int x,y; 说明x,y为外部整型变量
与指针有关的各种说明和意义见下表。
int *p; p为指向整型量的指针变量
int *p[n]; p为指针数组，由n个指向整型量的指针元素组成。
int (*p)[n]; p为指向整型二维数组的指针变量，二维数组的列数为n
int *p() p为返回指针值的函数，该指针指向整型量
int (*p)() p为指向函数的指针，该函数返回整型量
int **p p为一个指向另一指针的指针变量，该指针指向一个整型量。
指针变量的赋值
p可以有以下两种方式：
(1)指针变量初始化的方法 int a;
int *p=&a;
(2)赋值语句的方法 int a;
int *p;
p=&a;
(1)取地址运算符&
(2)取内容运算符*
㈢ c璇瑷镄勮烦杞鎸囦护鏄浠涔堬纻
C璇瑷璺宠浆鎸囦护鍖呭惈锛屽瓙绋嫔簭璋幂敤锛屾棤𨱒′欢杞绉伙纴𨱒′欢杞绉荤瓑銆傚傦细
int x,y
x=10;
y=sqr(10);//姝ゆ椂灏呜浆绉诲埌sqr鍑芥暟铡绘墽琛岋纴涓哄瓙绋嫔簭璋幂敤鍙戠敓镄勮烦杞
x=10;
goto sss;//姝ゆ椂灏呜烦杞鍒皊ss寮濮嬫墽琛岋纴涓烘棤𨱒′欢杞绉诲彂鐢熺殑璺宠浆
do{
i++;
}while(i<100) //褰搃灏忎簬100镞跺皢璺宠浆鍒板惊鐜镄勫紑濮嬬户缁镓ц岋纴涓烘浔浠惰浆绉
㈣ C语言预处理指令有哪些
我们可以在C源程序中插入传给编译程序的各中指令，这些指令被称为预处理器指令，它们扩充了程序设计的环境。现把常用的预处理命令总结如下：
1. 预处理程序
按照ANSI标准的定义，预处理程序应该处理以下指令：
#if #ifdef #ifndef #else #elif
#endif
#define
#undef
#line
#error
#pragma
#include
显然，上述所有的12个预处理指令都以符号#开始，，每条预处理指令必须独占一行。
2. #define
#define指令定义一个标识符和一个串（也就是字符集），在源程序中发现该标识符时，都用该串替换之。这种标识符称为宏名字，相应的替换称为宏代换。一般形式如下：
#define macro-name char-sequence
这种语句不用分号结尾。宏名字和串之间可以有多个空白符，但串开始后只能以新行终止。
例如：我们使用LEFT代表1，用RIGHT代表0，我们使用两个#define指令：
#define LEFT 1
#define RIGHT 0
每当在源程序中遇到LEFT或RIGHT时，编译程序都用1或0替换。
定义一个宏名字之后，可以在其他宏定义中使用,例如：
#define ONE 1
#define TWO ONE+ONE
#define THREE ONE+TWO
宏代换就是用相关的串替代标识符。因此，如果希望定义一条标准错误信息时，可以如下定义：
#define ERROR_MS “Standard error on input \n”
如果一个串长于一行，可在行尾用反斜线”\”续行，如下：
#define LONG_STRING “This is a very very long \
String that is used as an example”
3. #error
#error指令强制编译程序停止编译，它主要用于程序调试。#error指令的一般形式是：
#error error-message
注意，宏串error-message不用双引号包围。遇到#error指令时，错误信息被显示，可能同时还显示编译程序作者预先定义的其他内容。
4. #include
程序中的#include指令要求编译程序读入另一个源文件。被读入文件的名字必须用双引号(“”)或一对尖括号(<>)包围，例如：
#include “stdio.h”
#include <stdio.h>
都使C编译程序读入并编译头文件以用于I/O系统库函数。
包含文件中可以包含其他#include指令，称为嵌套包含。允许的最大嵌套深度随编译器而变。
文件名被双括号或尖括号包围决定了对指定文件的搜索方式。文件名被尖括号包围时，搜索按编译程序作者的定义进行，一般用于搜索某些专门放置包含文件的特殊目录。当文件名被双括号包围时，搜索按编译程序实时的规定进行，一般搜索当前目录。如未发现，再按尖括号包围时的办法重新搜索一次。
通常，绝大多数程序员使用尖括号包围标准的头文件，双引号用于包围与当前程序相关的文件名。
5. 条件编译指令
若干编译指令允许程序员有选择的编译程序源代码的不同部分，这种过程称为条件编译。
5.1#if、#else、#elif #endif
条件编译指令中最常用的或许是#if,#else,#elif和#endif。这些指令允许程序员根据常数表达式的结果有条件的包围部分代码。
#if的一般形式是：
#if constant-expression
Statement sequence
#endif
如#if后的常数表达式为真，则#if和#endif中间的代码被编译，否则忽略该代码段。#endif标记#if块的结束。
#else指令的作用与C语言的else相似，#if指令失败时它可以作为备选指令。例如：
#include <stdio.h>
#define MAX 100
Int main(void)
{
#if MAX>99
printf(“Compiled for array greater than 99.\n”);
#else
printf(“Complied for small array.\n”);
#endif
return 0;
}
注意，#else既是标记#if块的结束，也标记#else块的开始。因为每个#if只能写一个#endif匹配。
#elif指令的意思是“否则，如果”，为多重编译选择建立一条if-else-if（如果-否则-如果链）。如果#if表达式为真，该代码块被编译，不测试其他#elif表达式。否则，序列中的下一块被测试，如果成功则编译之。一般形式如下：
#if expression
Statement sequence
#elif expression1
Statement sequence
#elif expression2
Statement sequence
.
.
.
#elif expression
Statement sequence
#endif
5.2#ifdef和#ifndef
条件编译的另一个方法是使用编译指令#ifdef和#ifndef，分别表示“如果已定义”和“如果未定义”。#ifdef的一般形式如下：
#ifdef macro-name
Statement sequence
#endif
如果macro-name原先已经被一个#define语句定义，则编译其中的代码块。
#ifndef的一般形式是：
#ifndef macro-name
Statement sequence
#endif
如果macro-name当前未被#define语句定义，则编译其中的代码块。
我认为，用这种，可以很方便的开启/关闭整个程序的某项特定功能。
#ifdef和#ifndef都可以使用#else或#elif语句。
#inlucde <stdio.h>
#define T 10
Int main(void)
{
#ifdef t
Printf(“Hi T\n”);
#else
Printf(“Hi anyone\n”);
#endif
#ifndef M
Printf(“M Not Defined\n”);
#endif
Return 0;
}
6. #undef
#undef指令删除前面定义的宏名字。也就是说，它“不定义”宏。一般形式为：
#undef macro-name
7. 使用defined
除#ifdef之外，还有另外一种确定是否定义宏名字的方法，即可以将#if指令与defined编译时操作符一起使用。defined操作符的一般形式如下：
defined macro-name
如果macro-name是当前定义的，则表达式为真，否则为假。
例如，确定宏MY是否定义，可以使用下列两种预处理命令之一：
#if defined MY
或
#ifdef MY
也可以在defined之前加上感叹号”!”来反转相应的条件。例如，只有在DEBUG未定义的情况下才编译。
#if !defined DEBUG
Printf(“Final Version!\n”);
#endif
使用defined的一个原因是，它允许由#elif语句确定的宏名字存在。
8. #line
#line指令改变__LINE__和__FILE__的内容。__LINE__和__FILE__都是编译程序中预定义的标识符。标识符__LINE__的内容是当前被编译代码行的行号，__FILE__的内容是当前被编译源文件的文件名。#line的一般形式是：
#line number “filename”
其中，number是正整数并变成__LINE__的新值；可选的“filename”是合法文件标识符并变成__FILE__的新值。#line主要用于调试和特殊应用。
9. #pragma
#pragma是编译程序实现时定义的指令，它允许由此向编译程序传入各种指令。例如，一个编译程序可能具有支持跟踪程序执行的选项，此时可以用#pragma语句选择该功能。编译程序忽略其不支持的#pragma选项。#pragma提高C源程序对编译程序的可移植性。
10. 预处理操作符#和##
有两个预处理操作符：#和##，它们可以在#define中使用。
操作符#通常称为字符串化的操作符，它把其后的串变成用双引号包围的串。例如：
#include <stdio.h>
#define mkstr(s) #s
int main(void)
{
Printf(mkstr(I like C));
Return 0;
}
预处理程序把以下的语句：
Printf(mkstr(I like C));
变成
Printf(“I like C”);
操作符##把两个标记拼在一起，形成一个新标记。例如：
#include <stdio.h>
#define concat(a,a) a##b
int main(void)
{
Int xy = 10;
Printf(“%d”,concat(x,y));
Return 0;
}
预处理程序把以下语句：
Printf(“%d”,concat(x,y));
变成
Printf(“%d”,xy);
操作符#和##主要作用是允许预处理程序对付某些特殊情况，多数程序中并不需要。
11. 预定义宏
C规范了5个固有的预定义宏，它们是：
__LINE__
__FILE__
__DATE__
__TIME__
__STDC__
__LINE__和__FILE__包含正在编译的程序的行号和文件名。
__DATE__和内容形如month/day/year(月/日/年)的串，代表源文件翻译成目标码的日期。
__TIME__中的串代表源代码编译成目标码的时间，形如hour:minute:second(时：分：秒)
如果__STDC__的内容是十进制常数1，则表示编译程序的实现符合标准C。
㈤ 关于C语言预处理命令
C程序的源代码中可包括各种编译指令，这些指令称为预处理命令。虽然它们实际上不是C语言的一部分，但却扩展了C程序设计的环境。本节将介绍如何应用预处理程序和注释简化程序开发过程，并提高程序的可读性。ANSI标准定义的C语言预处理程序包括下列命令：
#define，#error，＃include，#if，#else，#elif，#endif，#ifdef，#ifndef，#undef，#line，#pragma等。非常明显，所有预处理命令均以符号#开头，下面分别加以介绍。
一 #define
命令#define定义了一个标识符及一个串。在源程序中每次遇到该标识符时，均以定义的串代换它。ANSI标准将标识符定义为宏名，将替换过程称为宏替换。命令的一般形式为：
#define identifier string
注意：
1该语句没有分号。在标识符和串之间可以有任意个空格，串一旦开始，仅由一新行结束。
2宏名定义后，即可成为其它宏名定义中的一部分。
3 宏替换仅仅是以文本串代替宏标识符，前提是宏标识符必须独立的识别出来，否则不进行替换。例如：
#define XYZ this is a tes
使用宏printf("XYZ")；//该段不打印"this is a test"而打印"XYZ"。因为预编译器识别出的是"XYZ"
4如果串长于一行，可以在该行末尾用一反斜杠' \'续行。
#defineLONG_STRING"this is a very long\
string that is used as an example"
5 C语言程序普遍使用大写字母定义标识符。
6 用宏代换代替实在的函数的一大好处是宏替换增加了代码的速度，因为不存在函数调用的开销。但增加速度也有代价：由于重复编码而增加了程序长度。
二 #error
命令#error强迫编译程序停止编译，主要用于程序调试。
#error指令使预处理器发出一条错误消息，该消息包含指令中的文本.这条指令的目的就是在程序崩溃之前能够给出一定的信息。
三 #include
命令＃i nclude使编译程序将另一源文件嵌入带有＃include的源文件，被读入的源文件必须用双引号或尖括号括起来。例如：
＃include"stdio.h"或者＃include<stdio.h>
这两行代码均使用C编译程序读入并编译用于处理磁盘文件库的子程序。
将文件嵌入＃i nclude命令中的文件内是可行的，这种方式称为嵌套的嵌入文件，嵌套层次依赖于具体实现。
如果显式路径名为文件标识符的一部分，则仅在那些子目录中搜索被嵌入文件。否则，如果文件名用双引号括起来，则首先检索当前工作目录。如果未发现文件，则在命令行中说明的所有目录中搜索。如果仍未发现文件，则搜索实现时定义的标准目录。
如果没有显式路径名且文件名被尖括号括起来，则首先在编译命令行中的目录内检索。如果文件没找到，则检索标准目录，不检索当前工作目录。
四 条件编译命令
有几个命令可对程序源代码的各部分有选择地进行编译，该过程称为条件编译。商业软件公司广泛应用条件编译来提供和维护某一程序的许多顾客版本。
#if、#else，#elif及#endif
#if的一般含义是如果#if后面的常量表达式为true，则编译它与#endif之间的代码，否则跳过这些代码。命令#endif标识一个#if块的结束。
#if constant-expression
statement sequence
#endif
Eg:
#define MAX 91
#include <iostream>
using namespace std;
int main()
{
#if MAX > 99
cout<<"MAX is bigger than 99"<<endl;
#elif MAX > 90
cout<<"MAX is bigger than 90"<<endl;
#else
cout<<"MAX is smaller than 90"<<endl;
#endif
return 0;
}
跟在#if后面的表达式在编译时求值，因此它必须仅含常量及已定义过的标识符，不可使用变量。表达式不许含有操作符sizeof（sizeof也是编译时求值）。
#else命令的功能有点象C语言中的else；#else建立另一选择（在#if失败的情况下）。注意，#else属于#if块。
#elif命令意义与ELSE IF 相同，它形成一个if else-if阶梯状语句，可进行多种编译选择。#elif 后跟一个常量表达式。如果表达式为true，则编译其后的代码块，不对其它#elif表达式进行测试。否则，顺序测试下一块。
#if expression
statement sequence
#elif expression1
statement sequence
#endif
在嵌套的条件编译中#endif、#else或#elif与最近#if或#elif匹配。
# ifdef 和# ifndef
条件编译的另一种方法是用#ifdef与#ifndef命令，它们分别表示"如果有定义"及"如果无定义"。# ifdef的一般形式是：
# ifdef macroname
statement sequence
#endif
#ifdef与#ifndef可以用于#if、#else，#elif语句中，但必须与一个#endif。
#define MAX 91
#include <iostream>
using namespace std;
int main()
{
#ifdef MAX
cout<<"hello,MAX!"<<endl;
#else
cout<<"where is MAX?"<<endl;
#endif
#ifndef LEO
cout<<"LEO is not defined"<<endl;
#endif
return 0;
}
命令#undef 取消其后那个前面已定义过有宏名定义。一般形式为：
#undef macroname
命令#line改变__LINE__与__FILE__的内容，它们是在编译程序中预先定义的标识符。命令的基本形式如下：
#line number["filename"]
其中的数字为任何正整数，可选的文件名为任意有效文件标识符。行号为源程序中当前行号，文件名为源文件的名字。命令#line主要用于调试及其它特殊应用。注意：在#line后面的数字标识从下一行开始的数字标识。
#line 100 "jia"
cout<<"#line change line and filename!"<<endl; //line 100
cout<<__LINE__<<endl; //101
cout<<__FILE__<<endl; //jia
五 #pragma
命令#pragma 为实现时定义的命令，它允许向编译程序传送各种指令。
#pragma的作用是设定编译器的状态或者是指示编译器完成一些特定的动作。#pragma指令对每个编译器给出了一个方法,在保持与C和C++语言完全兼容的情况下,给出主机或操作系统专有的特征。依据定义,编译指示是机器或操作系统专有的,且对于每个编译器都是不同的。
其格式一般为: #Pragma Para
1 message 参数。
Message 参数能够在编译信息输出窗口中输出相应的信息，这对于源代码信息的控制是非常重要的。其使用方法为：
#pragma message(“消息文本”)
当编译器遇到这条指令时就在编译输出窗口中将消息文本打印出来。
当在程序中定义了许多宏来控制源代码版本的时候，自己有可能都会忘记有没有正确的设置这些宏，此时可以用这条指令在编译的时候就进行检查。假设希望判断自己有没有在源代码的什么地方定义了_X86这个宏可以用下面的方法
#ifdef _X86
#pragma message(“_X86 macro activated!”)
#endif
当定义了_X86这个宏以后，应用程序在编译时就会在编译输出窗口里显示“_
X86 macro activated!”。就不会因为不记得自己定义的一些特定的宏而抓耳挠腮了。
2 code_seg 参数。
格式如：
#pragma code_seg( ["section-name"[,"section-class"] ] )
它能够设置程序中函数代码存放的代码段，当开发驱动程序的时候就会使用到它。
3 #pragma once (比较常用）
只要在头文件的最开始加入这条指令就能够保证头文件被编译一次。这条指令实际上在VC6中就已经有了，但是考虑到兼容性并没有太多的使用它。
4 #pragma hdrstop
表示预编译头文件到此为止，后面的头文件不进行预编译。BCB可以预编译头文件以加快链接的速度，但如果所有头文件都进行预编译又可能占太多磁盘空间，所以使用这个选项排除一些头文件。
有时单元之间有依赖关系，比如单元A依赖单元B，所以单元B要先于单元A编译。你可以用#pragma startup指定编译优先级，如果使用了#pragma package(smart_init) ，BCB就会根据优先级的大小先后编译。
5 #pragma resource "*.dfm"
表示把*.dfm文件中的资源加入工程。*.dfm中包括窗体外观的定义。
6 #pragma warning( disable : 4507 34; once : 4385; error : 164 )
等价于：
#pragma warning(disable:4507 34) /* 不显示4507和34号警告信息。如果编译时总是出现4507号警告和34号警告, 而认为肯定不会有错误，可以使用这条指令。*/
#pragma warning(once:4385) // 4385号警告信息仅报告一次
#pragma warning(error:164) // 把164号警告信息作为一个错误。
同时这个pragma warning 也支持如下格式：
#pragma warning( push [ ,n ] )
#pragma warning( pop )
这里n代表一个警告等级(1---4)。
#pragma warning( push )保存所有警告信息的现有的警告状态。
#pragma warning( push, n)保存所有警告信息的现有的警告状态，并且把全局警告等级设定为n。
#pragma warning( pop )向栈中弹出最后一个警告信息，在入栈和出栈之间所作的一切改动取消。例如：
#pragma warning( push )
#pragma warning( disable : 4705 )
#pragma warning( disable : 4706 )
#pragma warning( disable : 4707 )
//.......
#pragma warning( pop )
在这段代码的最后，重新保存所有的警告信息(包括4705，4706和4707)。
7 pragma comment(...)
该指令将一个注释记录放入一个对象文件或可执行文件中。
常用的lib关键字，可以帮连入一个库文件。
8 progma pack（n）
指定结构体对齐方式。#pragma pack(n)来设定变量以n字节对齐方式。
n 字节对齐就是说变量存放的起始地址的偏移量有两种情况：
第一、如果n大于等于该变量所占用的字节数，那么偏移量必须满足默认的对齐方式，
第二、如果n小于该变量的类型所占用的字节数，那么偏移量为n的倍数，不用满足默认的对齐方式。
结构的总大小也有个约束条件，分下面两种情况：如果n大于所有成员变量类型所占用的字节数，那么结构的总大小必须为占用空间最大的变量占用的空间数的倍数； 否则必须为n的倍数。
下面举例说明其用法。
#pragma pack(push) //保存对齐状态
#pragma pack(4)//设定为4字节对齐
struct test
{
char m1;
double m4;
int m3;
};
#pragma pack(pop)//恢复对齐状态
为测试该功能，可以使用sizeof（）测试结构体的长度！
㈥ C语言中很多的预处理指令include、define等等它们各自的意义分别是什么
include的作用： #include叫做“文件包含” / include 语句包含并运行指定文件。 功能：它的功能是用来指定文件的全部内容替换程序中的命令行，从而使指定的文件与当前源文件连成一个源文件 书写格式： #include <文件名> //表示编译系统根据系统头文件存放的目录路径去搜索系统头文件，而不是在源文件目录去查找 #include "文件名" //表示编译系统首先在当前的源文件目录中查找，若未找到才根据系统的头文件存放的目录路径去搜索系统头文件 //系统定义的头文件通常使用尖括号；用户自定义的头文件通常使用双引号。 //一般来说，如果为调用库函数而用#include命令来包含相关的头文件，则用尖括号，以节约查找时间。 //如果要包含的是用户自己编写的文件（这种文件一般都在用户当前的目录中），一般用双撇号。 //若文件不在当前目录中，在双撇号内应该给出文件路径（如#include"C:\wang\file2.h") ----------------- 1.#define 的作用 在C或C++语言源程序中允许用一个标识符来表示一个字符串，称为“宏”。被定义为“宏”的标识符称为“宏名”。在编译预处理时，对程序中所有出现的“宏名”，都用宏定义中的字符串去代换，这称为“宏代换”或“宏展开”。宏定义是由源程序中的宏定义命令完成的。宏代换是由预处理程序自动完成的。 在C或C++语言中，“宏”分为有参数和无参数两种。 2. 无参宏定义 无参宏的宏名后不带参数。 其定义的一般形式为： #define 标识符 字符串 其中的“#”表示这是一条预处理命令。凡是以“#”开头的均为预处理命令。“define”为宏定义命令。“标识符”为所定义的宏名。“字符串”可以是常数、表达式、格式串等。 例如： #define M (a+b) 它的作用是指定标识符M来代替表达式(a+b)。在编写源程序时，所有的(a+b)都可由M代替，而对源程序作编译时，将先由预处理程序进行宏代换，即用(a+b)表达式去置换所有的宏名M，然后再进行编译。 程序1： #define M (a+b) main(){ int s,y; printf("input a number: "); scanf("%d",&y); s=M*M; printf("s=%d\n",s); } 上例程序中首先进行宏定义，定义M来替代表达式(a+b),在 s= M * M 中作了宏调用。在预处理时经宏展开后该语句变为： S=(a+b)*(a+b) 但要注意的是，在宏定义中表达式(a+b)两边的括号不能少。否则会发生错误。 如当作以下定义后：#difine M (a)+(b) 在宏展开时将得到下述语句：S= (a)+(b)*(a)+(b) 对于宏定义还要说明以下几点： 1. 宏定义是用宏名来表示一个字符串，在宏展开时又以该字符串取代宏名，这只是一种简单的代换，字符串中可以含任何字符，可以是常数，也可以是表达式，预处理程序对它不作任何检查。如有错误，只能在编译已被宏展开后的源程序时发现。 2. 宏定义不是说明或语句，在行末不必加分号，如加上分号则连分号也一起置换。 3. 宏定义必须写在函数之外，其作用域为宏定义命令起到源程序结束。如要终止其作用域可使用#undef命令。 3. 带参宏定义 c语言允许宏带有参数。在宏定义中的参数称为形式参数，在宏调用中的参数称为实际参数。对带参数的宏，在调用中，不仅要宏展开，而且要用实参去代换形参。 带参宏定义的一般形式为： #define 宏名(形参表) 字符串 在字符串中含有各个形参。 带参宏调用的一般形式为： 宏名(形参表) 例如： #define M(y) ((y)*(y)+3*(y)) /*宏定义*/ .... k=M(5); /*宏调用*/ .... 在宏调用时，用实参5去代替形参y，经预处理宏展开后的语句为: k=5*5+3*5 程序2： #define MAX(a,b) (a>b)?a:b main(){ int x,y,max; printf("input two numbers: "); scanf("%d%d",&x,&y); max=MAX(x,y); printf("max=%d\n",max); } 上例程序的第一行进行带参宏定义，用宏名MAX表示条件表达式(a>b)?a:b，形参a,b均出现在条件表达式中。程序第七行max=MAX(x,y)为宏调用，实参x,y，将代换形参a,b。宏展开后该语句为： max=(x>y)?x:y; 用于计算x,y中的大数。