为什么C语言整型常量十进制形式的类型与八进制、十六进制的不一样？
由于一些编译器还不支持C99，所以下述的讨论范围一般在C89或C90内。&br&&br&C语言标准对整型常量的类型有这样的描述：如果没有后缀且是十进制形式的，那么它的类型根据其值的大小可能为int、long、unsigned long；如果为没有后缀且是八进制或十六进制的，根据值的大小可能为int、unsigned int、long、unsigned long。&br&&br&我想问，对于十进制形式的整型常量的类型为什么不经过unsigned int，直接从int跳到long；按理说它应该像八进制与十六进制一样，从小到大逐一遍历选取。&br&&br&注意：这里说的类型是指原来的类型，不是指在表达式中转换提升后的类型。&br&&br&这个问题可以算勉强解决了：为什么十进制形式不遍历unsigned int，它的类型遍历是从int、long再到unsigned long；在此总结多日来查阅参考得出的可能最主要的原因：（减少在移植时出问题）&br&&br&首先，当无符号类型与长度相同的有符号类型一起运算时，其结果类型对C语言来说是无法预料的，也就是说结果的类型将有具体的实现；为什么呢？是这样的：&br&&br&C语言规定：较长类型的整数至少要占有较短类型整数一样的空间，但它们可以占有一样大小的空间，这取决于具体的实现。&br&&br&因此当无符号类型与有符号类型运算时，比如，unsigned int与long int，当它们被规定为长度相同，那么结果是什么类型，仅从语法上来说，不能确定结果的类型，因为不知道一个unsigned int的数long int能不能装的下，如果装的下则在类型转换时将unsigned int转换成long int，结果类型为long int，装不下则将long int、unsigned int转换unsigned long int，结果类型为unsigned long int，所以在考虑到移植性时，应尽可能的用有符号类型int、long，这样不管在哪种环境下，实现在语言中就可以确定其类型，而且无符号类型的表数范围大于有符号类型，在运算中一般要将有符号类型转换成无符号类型，而这种转换要比反向转换复杂的多，占用更多的计算时间，显然选用unsigned int的弊大于不用unsigned int，不选用unsigned int的利大于选用unsigned int。&br&&br&语言设计者，在考虑到C程序的空间利用率、时间效率、移植性，作出一个好的折中（在设计领域有句话：一个好的设计取决于一个好的折中）：&br&&br&在尽量减少空间浪费的情况下，提高程序的运行效率和通用性。而这两点对于任何程序来说都是衡量的最主要标准。而空间可以在物理上扩大，这是必然趋势，效率与通用性则只能在程序中提高，虽然也可以提供更快的处理器，但这显然是种鲁莽的想法。&br&&br&对了，最后的unsigned long是在不得已的情况下选取的，因为在C99以前没有提供比它更大的整数类型。&br&&br&最后，感谢本问题所有的回答者、评论者，你们的回答与意见很关键，至少是启发性的、参考性的。&br&&br&本问题已求解。&br&&br&在上述有关unsigend int与long int的转换例子中：当long int不能装下unsigend int时，是同时将两个操作数都转换为unsigend long int，现已改正，原本错误为unsigend int。&br&&br&在此对“薛非”指出的错误的误解说声抱歉！对阅读者的误导更是惭愧！&br&&br&“无符号数”与“无符号类型”，“有符号数”与“有符号类型”，如Zerg Will所述的确是不同概念，现已在答案中一律更正为“类型”。&br&&br&对于语言引起的混乱之处说声抱歉！感谢Zerg Will提出的问题！&br&&br&欢迎参与者能够指出更多的问题，或者将答案补充的更加完善，这样以后有同样问题的人就可以不在这种问题上再多花精力查找资料寻求解答。
由于一些编译器还不支持C99，所以下述的讨论范围一般在C89或C90内。C语言标准对整型常量的类型有这样的描述：如果没有后缀且是十进制形式的，那么它的类型根据其值的大小可能为int、long、unsigned long；如果为没有后缀且是八进制或十六进制的，根据值的大小可能为int、unsigned int、long、unsigned long。我想问，对于十进制形式的整型常量的类型为什么不经过unsigned int，直接从int跳到long；按理说它应该像八进制与十六进制一样，从小到大逐一遍历选取。注意：这里说的类型是指原来的类型，不是指在表达式中转换提升后的类型。这个问题可以算勉强解决了：为什么十进制形式不遍历unsigned int，它的类型遍历是从int、long再到unsigned long；在此总结多日来查阅参考得出的可能最主要的原因：（减少在移植时出问题）首先，当无符号类型与长度相同的有符号类型一起运算时，其结果类型对C语言来说是无法预料的，也就是说结果的类型将有具体的实现；为什么呢？是这样的：C语言规定：较长类型的整数至少要占有较短类型整数一样的空间，但它们可以占有一样大小的空间，这取决于具体的实现。因此当无符号类型与有符号类型运算时，比如，unsigned int与long int，当它们被规定为长度相同，那么结果是什么类型，仅从语法上来说，不能确定结果的类型，因为不知道一个unsigned int…
按投票排序
更新简单来说，如果在int, long long之间再插入unsigned int，那么当我们写long long v = -时（注意-落在64位long long的合法范围内），会发现v的值其实是，这显然违背语义（想象一下如果我们写int v = -1结果发现v的值是1时会怎么喷Bjarne，逃-- 先前内容 --Po主关于oct和hex的答案是对的，但其余部分感觉有些问题（也许是我理解错了，请多多指教），我提一些（原谅我手头暂无C编译器，所以下面就先用C++来说明了）：1. Integer和LiteralPo主提到了“有符号数”和“无符号数”，这里有个误区：integer和integer literal不是一回事，所有的integer literal都是没有负号、正号这种东西的。具体来说，如果你写-1，在编译器眼里是一个“-”和一个decimal integer literal "1"；而不是"-1"作为一个decimal integer literal。2. Integer Literal Type事实上，正确的integer literal type应该使用signed类型，否则会出现坑爹的结果。为啥？上一点已经说了，integer literal是无所谓符号的，所以如果类型顺序是int（32位）, unsigned int（32位）, long（64位）这样的顺序，而integer literal恰好大于int小于unsigned int，那么这个integer literal就会被解释为unsigned int。那如果这个integer literal前面还有个负号，结果是不是就煞笔掉了？举个例子。因为decimal在C++11下已经不会被解释为unsigned了（和C99类似），所以这里就以hex为例。以下：std::cout && 0x8000000 && std::endl;
std::cout && -0x8000000 && std::endl;
std::cout && 0x && std::endl;
std::cout && -0x && std::endl;
std::cout && 0x && std::endl;
std::cout && -0x && std::endl;
在int是32位，long long是64位的新编译器上的输出结果会是：--第四个输出结果，我没有打漏负号哦！为啥会出现这么不科学的结果啊？刚才说了，因为这诡异的integer literal恰好大于int，但又小于unsigned int，所以就被诡异地解释成unsigned int了，然后前面又加了个负号（oh shit）……注意上述6个值都落在long long范围内，这意味着当我们写long long v = xx时，即便xx落在long long范围内v的值也不一定是xx（卧槽标准委员会你赶紧把unsigned都给我扔掉！）……如果乖乖用C++11下的decimal呢？std::cout && - && std::endl;
std::cout && - && std::endl;
std::cout && - && std::endl;
在int是32位，long long是64位的新编译器上的输出结果会是：---你看不牵涉到unsigned的decimal的结果多科学呀（注：在VS2013上第二个结果会有问题，因为出于兼容性它沿用了C89；g++或clang++不开启C++11也会有问题）！所以说嘛，C89在int, long之后补上unsigned long并不是个明智的做法。当然那时候没有long long，所以没啥问题。但这明显影响了扩展性啊对不。事实上，C99出来时有一篇paper吐槽过这个地方，具体名称我忘了，大概意思是这样的： & -1在C89会解释为false，在C99会解释为true，which one do you prefer？更糟糕的是，现在的标准不仅允许使用int, long和long long，还允许使用扩展类型：If an integer literal cannot be represented by any type in its list and an extended integer type (3.9.1) can represent its value, it may have that extended integer type. If all of the types in the list for the literal are signed, the extended integer type shall be signed. If all of the types in the list for the literal are unsigned, the extended integer type shall be unsigned. If the list contains both signed and unsigned types, the extended integer type may be signed or unsigned.上文来自C++11。要是现行标准用unsigned类型封顶，那在支持扩展类型的机器和不支持扩展类型的机器上就会出现完全不同的结果。总结Po主对oct和hex的看法基本是正确的，oct和hex之所以要允许unsigned，是因为使用它们的人很可能假定它们是unsigned的，然后就能去搞位运算什么的，所以标准就留着unsigned。但对于常用的decimal，支持unsigned只是在纯添乱。PS.我对C/C++的认识只停留在大一水平，在大一学了这两门语言后我基本没再碰过它们，所以如果上面的看法完全错误，那也很正常（对此我只能请求各位看客的原谅，浪费你们的时间了）。还是请大牛
来检查下吧，求轻喷，谢谢！
这个问题很有意思啊，提问者的问题是：对于十进制的为什么不经过unsigned int，直接从int跳到long；按理说它应该像八进制与十六进制一样，从小到大逐一选取。其实这个是不对的，因为不经过unsigned int才是正常的，反之八进制和十六进制表达式没有跳过这个才是不正常的。这是因为我们用16进制或者8进制的时候，更多是为了位运算，例如int是16位的，那么0xFFFF就用int装不下，这样就会变成32位的long，变成0x0000FFFF，很显然这是一种浪费，因为位运算根本用不着这么多位，譬如说我们要把x的高八位和y的低八位组合在一起，一般是这样写：(x&0xFF00)|(y&0xFF)因为int是16位的，就装不下0xFF00的正数，就必须升位成long，结果就会变成：(x&0x0000FF00)|(y&0xFF)最后得到的结果就莫名其妙变成了long型的。
C语言的整数类型，其实不是这么说的。这其实就跟重载差不多。我举个例子：typedef unsigned char byte;
byte a=100;
byte b=200;
int c = a + b;
byte d = a + b;
那你说a+b到底是什么类型呢？如果是int，为什么可以赋值成byte？如果是byte，为什么c的值是300而不是溢出了之后变小？当然C语言可能会有一套说辞，说什么运算的时候都提升成int啦，什么int可以隐式转换成byte啦，这只是为了不让你混乱而故意说成这样的而已。所以如果我们把a+b的类型看成是uint8 ∩ uint16 ∩ uint32 ∩ int8 ∩ int16 ∩ int32 那其实就很好办了。a+b，既是byte，也是int，所以他是byte和int的交集——必然可以隐式转换成byte，的同时也可以赋值给int。这种说法可能有些人看起来会很别扭，为什么300是byte？那你说我能不能当他是所有数字呢？我们知道int+int如果作为int溢出了，你用一个long long去接也没用，结果也是错的。这只能说C语言本来就不是那么严谨的东西。这样说就好理解了。对于一个字面量，譬如说“1”来讲，你当他是什么类型都可以的。所以其实你不必太纠结与这个说法。真实情况就是，C语言的数字之间长度乱转是没有语法错误地，unsigned long也可以把它隐式转换成unsigned int。当然这就导出本题的答案了：为什么unsigned int a=;是不对的？这是一个很奇怪的人为的规定，你要写L，强制他是unsigned long，就可以隐式转换成unsigned int了。
最终答案已在描述中公布，这里做几点补充：那么八进制与十六进制为什么要选择呢？理由很简单：因为这两种形式的整型常量能够很好的与二进制数对应，在一些对“位”需要严格控制的场合就会很方便，可以说它提供了对“位”细微的操作，因此保留unsigned int是很有必要的。至于有人会问，为什么不从short int开始呢？是这样的：int的空间长度在C语言规定是机器最为高效的位数，所以不得已，一般能够用int当然要用int。这一点是在实际代码中可以得到验证的。而且short int以及枚举常量、字符常量等在运算中会进行整型提升为int或unsigned int。
10进制数一般都是做数学运算。unsigned类型在数学计算中能不用就不用，所以跳过了所有可以跳过的unsigned，因为有个坑，unsigned是不存在“溢出”的，出错了都不知道。unsigned数和signed数在cpu计算时是使用的指令是不同的，unsigned上溢下溢不出错，自动循环。signed根据cpu不同及相关设置不同会置异常位或者产生一个异常。不过c标准没有定义有符号型整数溢出的行为，如gcc，专门有关于符号型溢出处理的编译开关。无符号型是不管的。-ftrapv
This option generates traps for signed overflow on addition, subtraction, multiplication operations. -fwrapv
This option instructs the compiler to assume that signed arithmetic overflow of addition, subtraction and multiplication wraps around using twos-complement representation. This flag enables some optimizations and disables other. This option is enabled by default for the Java front-end, as required by the Java language specification.
C语言标准对整型常量的类型有这样的描述：如果没有后缀且是十进制形式的，那么它的类型根据其值的大小可能为int、long、unsigned long；据我所知，C语言的最新标准不是这样规定的楼主所说的标准是哪个？C90?C11的规定是intlonglong long因此当无符号数与有符号数运算时，比如，unsigned int与long int，当它们被规定为长度相同，那么结果是什么类型，仅从语法上来说，不能确定结果的类型，因为不知道一个unsigned int的数long int能不能装的下，如果装的下则在类型转换时将unsigned int转换成long int，结果类型为long int，装不下则将long int转换unsigned int，结果类型为unsigned int这个说法同样是错误的。因为如果long表示不了那个unsigned操作数时，结果类型并不是unsigned int，而是unsigned long
题主虽然说问题已解答，但是答案感觉有点牵强，我来说说我的想法。题目中问的是整形常量的类型，各位的答案都有些跑偏了，看来有必要重申一下什么是整形常量。int a =100;int b = a * 2;100是整形常量，2也是整形常量，所以讨论应该限定在这个范围内。在讨论前，我用 Dev-C++ 5.6.0 (操作系统是 WIN7 64bit 家庭版)做了一些实验：准备：
int 类型 4
long 类型 4
unsigned int 类型 4
unsigned long 类型 4
long long 类型 8
int 类型值的范围：-~
unsigned int 类型值的范围：0~实验1：
printf("a:%d\n",a);结果：
a:-1实验2：
printf("a:%u\n",a);结果：
unsigned int a = ;
printf("a:%d\n",a);结果：
a:-1实验4：
unsigned int a = ;
printf("a:%u\n",a);结果：
int a = -1;
printf("a:%u\n,a);结果：
a:以上5个实验说明了无论是 int 还是 unsigned int，它们在内存中存储的内容都是一致的，在此我用的是 0xFFFFFFFF，使用 %d 打印出来时显示的是 -1(说明计算机采用补码表示负数)，使用 u% 打印出来的就是 。以上5个实验是为了让大家直观的感受 int 和 unsigned int 的关系，很明显地可以看出，int 和 unsigned int 实质上没有区别，在内存中可以存储相同的内容，只是在按不同类型表示时，结果不一样，如 %d 是按有符号十进制显示，%u 是按无符号十进制显示。接下来再做一个实验。实验6：
printf("a:%u\n",a);结果：
a:0实验6说明了等式右边的常量超出了 4 byte (0x1 )以后，对于 a 的赋值，只截取后 4 byte 的内容。开始结论：
做了这么几个实验，相信大家心中都有一些谱了，我之所以没有用十六进制和八进制常量来做实验，是因为通过以上的实验，题主的问题已经不是问题了，也就是说不用再纠结整型常量是什么类型了。
为什么呢？
因为问题的关键不在于整型常量是什么类型，关键在于赋值给什么样的类型，因为不管你的整形常量是什么类型，最后都必须转换为被赋值变量的类型。
前5个实验说明了 int 和 unsigned int 其实没实质区别，所以题主中的少了一个 unsigned int 也没什么大不了，因为我用 int 也可以存储 unsigned int 的内容，然后在使用时当作 unsigned int 结果也是正确的；实验6中， 超过了 int 的 4 byte，实际上应该是 long long 类型，但是最后赋值给 int，高位的数据还是给截掉了，所以你等式右边是什么类型都无所谓，int 关心的只是你低 4 byte 的内容。回答补充----------------------------------------------------------------我大概理解你后一段话的意思：int a = 100；int b = a +
// 在 ~ 之间，int 表示范围之外，unsigned 表示范围之内在上面的的代码中， 其实可以用 unsiged int 来表示，在我的编译环境中，long 和 int 都是 4 byte，但是有些计算机 long 可能是 8byte，跳过 unsigned int ，也就是说
会变成 long 类型，在计算中占用了 8 byte，不仅如此，a +
中的 a 还会被隐式转换成 long 类型来进行运算，在赋值给 b 时运算结果又被强制转换成 int 类型。很可惜，我的编译环境没法直接给出答案，所以只能从侧面验证，如果不转换为更高字节的类型会怎么样：1.加减法上面有提到一个小细节，就是负数是采用的是补码。例1：unsigned int a = ; //0x80 00 00 00, 最高位是1int b = a - 1;printf("a:%d\nb:%d\n",a,b);结果：a:-b:再看一个例2：int a = ; //0x80 00 00 00, 最高位是1int b = a - 1;printf("a:%d\nb:%d\n",a,b);结果：a:-b:2.乘除法乘法就没什么讨论的，反正问题点就是溢出我们看看除法例3.int a = ;int b = a/2;printf("a:%d\nb:%d\n",a,b);a:-b:-例4.unsigned int a = ;int b = a/2;printf("a:%d\nb:%d\n",a,b);a:-b:从上面的例子看到当把 unsigned int 和 int 在运算中的差别，所以我觉得是为了保证十进制数的运算的一致性，~ 之间的数如果作为 unsigned int 的话，如果用来跟 int 变量进行运算，那么运算的结果会不可控（主要是 unsigned int 和 int 之间的转换），除非对编译器的工作方式很了解；如果指定为 long 的话，那么和 unsigned int 和 int 进行运算时，结果都是可控的（短类型转换为长类型没有信息的丢失）。为什么八进制十六进制可以使用 unsigned int，因为八进制和十六进制其实是为了方便表示二进而使用的，八进制的一位表示二进制的三位，十六进制的一位表示二进制的四位，八进制和十六进制不使用负数，因为正负的表示是看最高位是否为1，所以正负就直接在八进制和十六进制的数中表现出来了，不过也极少用八进制和十六进制表示负数，也很少用八进制和十六进制来进行数学运算，一般都是位运算，关心的只是它在内存中的值和长度，不关心它的类型，所以 int 和 unsigned int 也就无所谓。当然，以上的理解都是基于 long 比 int 要长的情况；如果是一样长，有没有 unsigned int 我觉得没什么差别。以上只是我个人的理解···
已有帐号？
无法登录？
社交帐号登录计算机数据库中“常量”是什么意思？_百度知道
计算机数据库中“常量”是什么意思？
　　常量是指在程序运行过程中其值不能改变的量。常量分为直接常量和符号常量。直接常量。　　“常量”在程序运行时，不会被修改的量。换言之，常量虽然是为了硬件、软件、编程语言服务，但是它并不是因为硬件、软件、编程语言而引入。　　常量区分为不同的类型，如25、0、-8为整形常量，6.8、-7.89为实型常量，‘a’‘b’为字符常量。常量一般从其字面形式即可判断。这种常量称为字面常量或直接常量。
其他类似问题
为您推荐：
常量是用来代替一个数或字符串的名称。一些随 ASP 提供的基本组件，例如 ActiveX Data Objects (ADO)，定义了您在脚本中可以使用的常量。组件可在一个组件类型库中声明常量，组件类型库是一个包含 ActiveX 组件所支持的对象和类型的信息的文件。一旦在 Global.asa 文件中声订厂斥断俪登筹券船猾明了一个类型库，您就可以在该应用程序的任意页中使用已定义的常量。
1:定义用户自定义类型对象2:定义ADO对象,用于对数据库操作3:定义常量,在程序运行中不可改变值4:声明API函数,系统提供的键盘操作的APIPrivate 私有Public 公有
计算机数据库的相关知识
等待您来回答
下载知道APP
随时随地咨询
出门在外也不愁【图文】C语言第02章_百度文库
两大类热门资源免费畅读
续费一年阅读会员，立省24元！
评价文档：
C语言第02章
上传于||暂无简介
大小：69.00KB
登录百度文库，专享文档复制特权，财富值每天免费拿！
你可能喜欢计算机中提到的identifier是什么意思_百度知道
计算机中提到的identifier是什么意思
他或她的名字。所以、人，如果您这样想，在电脑语言中。同样的道理，后面一般为一个或两个字，对于变量，都要用到它，比如；在数学中解方程时，语句块也有名字。我们在给人起名字时有一定的规矩，您可以想当然地认为电脑语言里的标识符也有一定的命名规则，我们统统称之为标识符，头一个字为父亲或母亲的姓氏，我们也常常用到这样或那样的变量名或函数名是，函数：标识符标识符是用户编程时使用的名字，常量。我们指定某个东西，那您就想对了
其他类似问题
为您推荐：
计算机的相关知识
等待您来回答
下载知道APP
随时随地咨询
出门在外也不愁define（计算机专业用语）_百度百科
?计算机专业用语
（计算机专业用语）
define，无参宏定义的一般形式为：#define
字符串define 函数定义一个常量。常量类似变量，不同之处在于：在设定以后，常量的值无法更改。常量名不需要开头的美元符号 ($)。不影响对常量的访问 。常量值只能是字符串或数字。
define参数
#define GPEBLT_FUNCNAME(basename) (SCODE (GPE::*)(struct GPEBltParms *))&GPE::##basename
在#define中，标准只定义了#和##两种操作。#用来把参数转换成字符串，##则用来连接前后两个参数，把它们变成一个字符串。
#include&stdio.h&
#define&paster(n)&printf(&token&#n&=%d\n&,token##n)
int&main(void)
int&token9=10;
paster(9);
输出为:token 9 = 10
详见百科（相似）。
define作用
被定义为“宏”的标识符称为“宏名”。在编译预处理时，对程序中所有出现的“宏名”，都用中的字符串去代换，这称为“宏代换”或“宏展开”。宏定义是由中的宏定义命令完成的。宏代换是由预处理程序自动完成的。
宏定义的作用范围仅限于当前文件，即file1.c中定义 #define PI 3.14，在file2.c中该宏定义不起作用；通过将#define PI 3.14定义在common.h中，file1.c和file2.c分别#include &common.h&的方式，该宏定义在file1.c和file2.c中都起作用。
在C或C++语言中，“宏”分为有参数和无参数两种。
define宏定义优点
(1) 方便程序的修改
使用简单可用宏代替一个在程序中经常使用的，这样在将该常量改变时，不用对整个程序进行修改，只修改宏定义的字符串即可，而且当常量比较长时， 我们可以用较短的有意义的来写程序，这样更方便一些。我们所说的常量改变不是在程序运行期间改变，而是在编程期间的修改，举一个大家比较熟悉的例 子，圆周率π是在数学上常用的一个值，有时我们会用3.14来表示，有时也会用3.1415926等，这要看计算所需要的精度，如果我们编制的一个程序中 要多次使用它，那么需要确定一个数值，在本次运行中不改变，但也许后来发现程序所表现的精度有变化，需要改变它的值， 这就需要修改程序中所有的相关数值，这会给我们带来一定的不便，但如果使用宏定义，使用一个来代替，则在修改时只修改宏定义即可，还可以减少输入 3.1415926这样长的数值多次的情况，我们可以如此定义 #define pi 3.1415926，既减少了输入又便于修改，何乐而不为呢？
(2) 提高程序的运行效率
使用带参数的宏定义可完成的功能，又能减少系统开销，提高运行效率。正如C语言中所讲，函数的使用可以使程序更加模块化，便于组织，而且可重复利用，但在发生函数调用时，需要保留调用函数的现场，以便子函数执行结束后能返回继续执行，同样在子函数执行完后要恢复调用函数的现场，这都需要一定的时间，如果子函数执行的操作比较多，这种转换时间开销可以忽略，但如果子函数完成的功能比较少，甚至于只完成一点操作，如一个乘法语句的操作，则这部分转换开销就相对较大了，但使用带参数的就不会出现这个问 题，因为它是在预处理阶段即进行了宏展开，在执行时不需要转换，即在当地执行。宏定义可完成简单的操作，但复杂的操作还是要由来完成，而且宏定义所占用的空间相对较大。所以在使用时要依据具体情况来决定是否使用宏定义。
define无参宏定义
无参宏定义的一般形式为：#define
其中的“#”表示这是一条。凡是以“#”开头的均为预处理命令。“define”为命令。“标识符”为所定义的宏名。“字符串”可以是常数、、格式串等。
例如：　#define M (a+b)　它的作用是指定标识符M来代替表达式(a+b)。在编写时，所有的(a+b)都可由M代替，而对源程序作编译时，将先由预处理程序进行宏代换，即用(a+b)表达式去置换所有的宏名M，然后再进行编译。
#include&stdio.h&
#define&M&(a+b)
int&main(void)
int&s,a,b;
printf(&inputnumbera&b:&);
scanf(&%d%d&,&a,&b);
printf(&s=%d\n&,s);
上例程序中首先进行，定义M来替代(a+b),在 s= M * M 中作了宏调用。在预处理时经宏展开后该语句变为： S=(a+b)*(a+b) 　但要注意的是，在宏定义中表达式(a+b)两边的括号不能少。否则会发生错误。 　如当作以下定义后：#define M (a)+(b) 　在宏展开时将得到下述语句：S= (a)+(b)*(a)+(b)
对于宏定义还要说明以下几点：
1.宏定义是用宏名来表示一个字符串，在宏展开时又以该字符串取代宏名，这只是一种简单的代换，字符串中可以含任何字符，可以是常数，也可以是表达式，预处理程序对它不作任何检查。如有错误，只能在编译已被宏展开后的源程序时发现。
2.不是说明或语句，在行末不必加分号，如加上分号则连分号也一起置换。
3.宏定义其为宏定义命令起到源程序结束。如要终止其作用域可使用#undef命令。 　（有关#undef 请查阅其他资料）
define带参宏定义
允许宏带有参数。在中的参数称为，在宏调用中的参数称为。对带参数的宏，在调用中，不仅要宏展开，而且要用去代换。
带参宏定义的一般形式为： 　#define 宏名(形参表) 字符串
在字符串中含有各个形参。 带参宏调用的一般形式为： 　宏名(形参表)
#defineM(y)((y)*(y)+3*(y))/*宏定义*/
k=M(5);/*宏调用*/
在宏调用时，用5去代替y，经预处理宏展开后的语句为: 　k=5*5+3*5
//#include&cstdio&
#include&stdio.h&
#define&MAX(a,b)((a&b)?(a):(b))
intmain(intargc,char*argv[])
printf(&inputtwonumbers:&);
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中的大数。
头文件(.h)可以被头文件或C文件包含；重复包含（重复定义）由于头文件包含可以嵌套，那么C文件就有可能包含多次同一个头文件，就可能出现重复定义的问题的。 通过条件编译开关来避免重复包含（重复定义）
#ifndef__headerfileXXX__
#define__headerfileXXX__
//文件内容
详见百科#typedef（相似）
definePHP用法
define() 函数定义一个常量。
类似变量，不同之处在于：
在设定以后，常量的值无法更改
常量名不需要开头的美元符号 ($)
不影响对常量的访问
常量值只能是或数字
define例子
define例子 1
定义一个大小写敏感的常量：
&?phpdefine(&GREETING&,&Helloworld!&);echoconstant(&GREETING&);?&
Hello world!
define例子 2
定义一个大小写不敏感的：
&?phpdefine(&GREETING&,&Helloworld!&,TRUE);echoconstant(&greeting&);?&
Hello world!