编译预命令必须以什么开头

㈠ 预处理命令在书写格式上有什么要求

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

㈡ C语言有效的预处理命令总是以什么开头

C语言中，所有预处理命令都是以“#”号开头的。

C语言程序设计预处理的概念：在编译之前进行的处理。 C语言的预处理主要有三个方面的内容：宏定义、文件包含、条件编译。

(2)编译预命令必须以什么开头扩展阅读：

1、宏定义：正确的宏定义是#defineS(r) ((r)*(r))

（1）宏名和参数的括号间不能有空格

（2）宏替换只作替换，不做计算，不做表达式求解

（3）函数调用在编译后程序运行时进行，并且分配内存。宏替换在编译前进行，不分配内存

（4）宏的哑实结合不存在类型，也没有类型转换。

（5）宏展开使源程序变长，函数调用不会

（6）宏展开不占运行时间，只占编译时间，函数调用占运行时间（分配内存、保留现场、值传递、返回值）。

2、文件包含：格式：#include "文件名"或#include <文件名>；编译时以包含处理以后的文件为编译单位，被包含的文件是源文件的一部分。编译以后只得到一个目标文件.obj，被包含的文件又被称为“标题文件”或“头部文件”、“头文件”，并且常用.h作扩展名。

3、条件编译

格式：

（1）#ifdef 标识符 程序段1 #else 程序段2 #endif 或#ifdef 程序段1 #endif；

（2）#ifndef标识符 #define 标识1 程序段1 #endif；

（3）#if表达式1 程序段1 #elif 表达式2 程序段2 …… #elif 表达式n 程序段n #else 程序段n+1 #endif。

使用条件编译可以使目标程序变小，运行时间变短。

㈢ 常见的预处理命令有哪两种

很多小伙伴在自己写代码的时候，已经多次使用过include命令。使用库函数之前，应该用include引入对应的头文件。其实这种以#号开头的命令称为预处理命令。

C语言源文件要经过编译、链接才能生成可执行程序：

1) 编译（Compile）会将源文件（.c文件）转换为目标文件。对于 VC/VS，目标文件后缀为.obj；对于GCC，目标文件后缀为.o。

编译是针对单个源文件的，一次编译操作只能编译一个源文件，如果程序中有多个源文件，就需要多次编译操作。

2) 链接（Link）是针对多个文件的，它会将编译生成的多个目标文件以及系统中的库、组件等合并成一个可执行程序。

关于编译和链接的过程、目标文件和可执行文件的结构、.h 文件和 .c 文件的区别，我们将在后期专题中讲解。

在实际开发中，有时候在编译之前还需要对源文件进行简单的处理。例如，我们希望自己的程序在 Windows 和 Linux 下都能够运行，那么就要在 Windows 下使用 VS 编译一遍，然后在 Linux 下使用 GCC 编译一遍。但是现在有个问题，程序中要实现的某个功能在 VS 和 GCC 下使用的函数不同（假设 VS 下使用 a()，GCC 下使用 b()），VS 下的函数在 GCC 下不能编译通过，GCC 下的函数在 VS 下也不能编译通过，怎么办呢？

这就需要在编译之前先对源文件进行处理：如果检测到是 VS，就保留 a() 删除 b()；如果检测到是 GCC，就保留 b() 删除 a()。

这些在编译之前对源文件进行简单加工的过程，就称为预处理（即预先处理、提前处理）。

预处理主要是处理以开头的命令，例如include <stdio.h>等。预处理命令要放在所有函数之外，而且一般都放在源文件的前面。

预处理是C语言的一个重要功能，由预处理程序完成。当对一个源文件进行编译时，系统将自动调用预处理程序对源程序中的预处理部分作处理，处理完毕自动进入对源程序的编译。

编译器会将预处理的结果保存到和源文件同名的.i文件中，例如 main.c 的预处理结果在 main.i 中。和.c一样，.i也是文本文件，可以用编辑器打开直接查看内容。

C语言提供了多种预处理功能，如宏定义、文件包含、条件编译等，合理地使用它们会使编写的程序便于阅读、修改、移植和调试，也有利于模块化程

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

#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

㈤ 为什么A是对的，预处理命令行都必须以#号开始 才是对的把

因为如果代码是注释它就不起作用了。

如/*注释#define。

B、预处理命令行不可以 宏定义是可以的。

C、程序在执行过程中对预处理命令行进行处理。是在执行过程之前，所以才称为预处理，就是先于程序处理的意思，这是对的。

宏定义又称为宏代换、宏替换，简称“宏”。格式：#define标识符文本，其中的标识符就是所谓的符号常量，也称为“宏名”。

D、对预处理命令行的处理是在编译之前完成的，不是程序执行的过程中，选D。

(5)编译预命令必须以什么开头扩展阅读：

正确的宏定义是#define S(r) ((r)*(r))

（2）宏名和参数的括号间不能有空格

（3）宏替换只作替换，不做计算，不做表达式求解

（4）函数调用在编译后程序运行时进行，并且分配内存。宏替换在编译前进行，不分配内存

（5）宏的哑实结合不存在类型，也没有类型转换。

（6）宏展开使源程序变长，函数调用不会

（7）宏展开不占运行时间，只占编译时间，函数调用占运行时间（分配内存、保留现场、值传递、返回值）。

㈥ 编译预处理命令中什么字符作为首字符

#include "stdio.h"，#define P 3。void *F(int x)/*定义一个无类型函数，它有返回值，只是返回的值是指向无类型数据的指针*/
void main(){printf("%d ",(int)F(1+3));/*将无类型函数F返回的指针值通过(int)强制转换为int型*/
编译器在编译源代码时都是从开头到结尾依次读取，自己定义的变量、宏等等都得放前面，这样在编译器在读到它们时就作一个记录；在使用这些变量、宏时，编译器会在记录中去寻找，如果找不到就会报错——此变量未被定义。函数可以放在结尾（main()之后），但是必须在开头作一个函数声明（也叫函数原型）以使编译器为它作记录，以便以后使用它时可以在记录中找到它。
函数也可以放在前面（main()之前），此时就不用再声明了，编译器在读到它时也会作一个记录。总之，自己定义的东西都得先声明后使用，否则使用时在记录中会找不到它。预处理命令也是自己定义的东西，同属这一范畴。

㈦ C++中预处理指令是什么

C++中，预处理命令是以#号开头，结尾没有分号的命令行。这些命令会在编译开始前由编译器执行。有三种预处理命令：
1. 宏定义；
2. 文件包含；
3. 条件编译。
宏定义命令格式为：
#define 标识符 替换文本
其中＂标识符＂称为宏名，替换文本可以是任意的字符串。执行宏替换时编译器将全部的宏名替换为替换文本。
文件包含命令格式为：
#include <文件名> 或#include "文件名"
文件名用尖括号或双引号括起来都是合法的。一般预设头文件用尖括号，自定义头文件用双引号。原因：用双引号会先在当前目录下查找。
条件编译命令有很多种格式，这里只列出并解释其中两种：
格式1：
#ifdef 标识符
程序段1
#else
程序段2
#endif
它的意思是：如果标识符已经被宏定义，则编译程序段1，否则编译程序段2。
格式2：
#ifndef 标识符
程序段1
#else
程序段2
#endif
它的意思是：如果标识符没有被宏定义，则编译程序段1，否则编译程序段2。

㈧ 预处理命令行必须位于C源程序的起始位置吗

预处理命令是以“#”号开头的命令，它们不是C语言的可执行命令，这些命令应该在函数之外书写，一般在源文件的最前面书写，称为预处理部分。在C编译系统编译源程序之前，先要对源程序中的预处理命令进行处理，处理完毕之后才能对源程序进行编译。在全屏幕编辑环境下，预处理是在编译之前自动由系统处理的。 因为大多数程序都用这个printf函数，而这个函数的头文件是“stdio.h”，所以一般要包括上。

㈨ 预处理指令只能位于C源程序文件的首部吗 为什么

不一定的，一般来说是要放在文件的首部的，1、防止编译时出现，还没有引入就使用的情况（如一些库函数等的）；2、代码看起来美观，大方，便于阅读和修改