❶ C语言预编译命令中 NEXT、NX_CURRENT_COMPILER_RELEASE 是什么含义
076#ifdefNEXT
077#if(NX_CURRENT_COMPILER_RELEASE==410)
078#ifdefm68k
079#defineHZ64
080#else
081#defineHZ100
082#endif
083#else
084#include<machine/param.h>
085#endif
086#endif/**NEXT*/
087
之前没有打开~~这里设置参数的~~其实原理还是一样的~~怕重复包含~~重复定义
其实没有什么其他意思~~~就是区分本文件是否被包含~~因为如果重复包含就会发生重定义错误~~所以文件只能被包含一次~~所以这里的NEXT可以改成其他的~~还有那个长长的也可以高出其他的
❷ 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++中的预编译命令，#include "wtypes.h"一般用来干啥
包含头文件 原因是你程序内使用到到了这个文件的函数或其他东西
❹ C语言 预处理命令
这样的 M(a+b,b+c,c+a) 替换到 x*y+z 表达式为 a+b*b+c+c+a 结果就为12了么
想要得到19 就应该这样 （x）*（y）+z
❺ 一般地,调用标准字符或格式输入输出库函数时,文件开头应有以下预编译命令:___
编译，编译程序读取源程序（字符流），对之进行词法和语法的分析，将高级语言指令转换为功能等效的汇编代码，再由汇编程序转换为机器语言，并且按照操作系统对可执行文件格式的要求链接生成可执行程序。
❻ 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 "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
❽ 内联函数和预编译命令有什么区别
内联函数只是为了减少函的跳转来提高程序运行效率的方式。
❾ 编译和预编译有什么区别。
预编译又称为预处理，是做些代码文本的替换工作。
处理#开头的指令，比如拷贝#include包含的文件代码，#define宏定义的替换,条件编译等
就是为编译做的预备工作的阶段
主要处理#开始的预编译指令
编译(compilation , compile) 1、利用编译程序从源语言编写的源程序产生目标程序的过程。 2、用编译程序产生目标程序的动作。 编译就是把高级语言变成计算机可以识别的2进制语言，计算机只认识1和0，编译程序把人们熟悉的语言换成2进制的。
❿ C语言预编译命令#include<myfile.h>与#include"myfile.h"的功能
正确。
在用法上，只是查找文件路径的顺序不同，<>包含，会默认优先查找系统文件，然后是工程文件和当前目录下文件，而""包含，会默认优先查找当前工程和目录下文件，这对于自定义头文件是没有区别的。