整型常量
1. 八进制整常数
八进制整常数必须以0开头，即以0作为八进制数的前缀。数码取值为0～7。八进制数通常是无符号数。 以下各数是合法的八进制数：
015(十进制为13) 0101(十进制为65) 0177777(十进制为65535)
以下各数不是合法的八进制数：
256(无前缀0) 03A2(包含了非八进制数码) -0127(出现了负号)
2. 十六进制整常数
十六进制整常数的前缀为0X 或0x 。其数码取值为0~9，A~F或a~f。
以下各数是合法的十六进制整常数：
0X2A(十进制为42) 0XA0 (十进制为160) 0XFFFF (十进制为65535)
以下各数不是合法的十六进制整常数：
5A (无前缀0X) 0X3H (含有非十六进制数码)
3. 十进制整常数
十进制整常数没有前缀。其数码为0～9。
以下各数是合法的十进制整常数：
237 -568 65535 1627
以下各数不是合法的十进制整常数：
023 (不能有前导0) 23D (含有非十进制数码)
在程序中是根据前缀来区分各种进制数的。因此在书写常数时不要把前缀弄错造成结果不正确。
4. 整型常数的后缀
在16位字长的机器上，基本整型的长度也为16位，因此表示的数的范围也是有限定的：
十进制无符号整常数的范围为0～65535，有符号数为-32768～+32767。
八进制无符号数的表示范围为0～0177777。
十六进制无符号数的表示范围为0X0～0XFFFF 或0x0～0xFFFF 。
如果使用的数超过了上述范围，就必须用长整型数来表示。长整型数是用后缀“L”或“l”来表示的。例如： 十进制长整常数 158L (十进制为158) 358000L (十进制为-358000)
八进制长整常数 012L (十进制为10) 077L (十进制为63) 0200000L (十进制为65536)
十六进制长整常数 0X15L (十进制为21) 0XA5L (十进制为165) 0X10000L (十进制为65536)
长整数158L 和基本整常数158 在数值上并无区别。但对158L ，因为是长整型量，Ｃ编译系统将为它分配4个字节存储空间。而对158，因为是基本整型，只分配2 个字节的存储空间。因此在运算和输出格式上要予以注意，避免出错。无符号数也可用后缀表示，整型常数的无符号数的后缀为“U”或“u”。例如： 358u,0x38Au,235Lu 均为无符号数。前缀，后缀可同时使用以表示各种类型的数。如0XA5Lu 表示十六进制无符号长整数A5，其十进制为165。
整型变量 1. 分类
整型变量可以分为以下4类：
(1)短整型，类型关键字为short[int]。
类型说明符为short int或short'C110F1。所占字节和取值范围会因不同的编译系统而有差异。对于16字机，short int 占2个字节，在大多数的32位机中，short int 占4个字节。但总的来说，short int 至少16位，也就是2个字节。
(2)基本整型，类型关键字为int 。
类型说明符为int ，在内存中占4个字节（不同系统可能有差异，此处原为2，经查证windows 系统下为4，VAX 系统也如此） ，其取值为基本整常数
(3)长整型，类型关键字为long[int]。
类型说明符为long int或long ，在内存中占4个字节，其取值为长整常数。在任何的编译系统中，长整型都是占4个字节。在一般情况下，其所占的字节数和取值范围与基本型相同。 (4)无符号整型，类型关键字为unsigned[int]或unsignedshort 或unsignedlong 。
unsigned[int]表示无符号基本整型；
unsignedshort 表示无符号短整型；
unsignedlong 表示无符号长整型。
无符号整型只能用来存储无符号整数。
类型说明符为unsigned 。在编译系统中，系统会区分有符号数和无符号数，区分的根据是如何解释字节中的最高位，如果最高位被解释为数据位，则整型数据则表示为无符号数
无符号型
各种无符号类型量所占的内存空间字节数与相应的有符号类型量相同。但由于省去了符号位，故不能表示负数。 下表列出了Turbo C中各类整型量所分配的内存字节数及数的表示范围。
类型说明符 数的范围 分配字节数
int -32768~32767
short int -32768~32767
signed int -32768~32767
unsigned int 0~65535
long int -2147483648~2147483647
unsigned long 0~4294967295
变量说明的一般形式为
类型说明符 变量名标识符，变量名标识符，...;
例如
int a,b,c; (a,b,c为整型变量)
long x,y; (x,y为变量)
unsigned p,q; (p,q为无符号整型变量)
定义整型变量的格式是
整数类型 1个变量名或用逗号格开的多个变量名
类似地，还可以定义 unsigned int 、 unsigned long 型的变量。
定义一个变量，意味着在内存中给这个变量分配了相应大小的存储空间，同时确定了这个变量值的存储方式和可以进行的操作
2. 占用内存字节数与值域
上述各类型的整型变量占用的内存字节数随系统而异，一般以一个机器字(word)存放一个int 型数据，而long 型数据的字节数应不小于int 型，short 型不长于int 型。在16位
操作系统(例如DOS) 中，一般用2字节存放一个int 型数据；在32位操作系统(例如Win-dows98) 中，默认为4字节。
本节选用16位系统，各类整型数据的存储情况及取值范围如表6-1所示。
显然，不同类型的整型变量，其值域不同。占用内存字节数为n 的有符号整型变量，其值域为-2n*8-1 ～2n*8-1-1; 无符号整型变量的值域为0～2n*8 -1。例如,16位操作系统中
的一个int 型变量，其值域为-22*8-1～22*8-1-1, 即-32 768～32 767；一个unsigned 型变量的值域为0～2 2*8 -1，即0～65535。
【例6.1】 整型数据程序示例。
main()
{inta，b ，c ，d ；
a=10，b=5；
c=a+b；
d=32767+1；
printf(″c=%d\n″，c) ；
printf(″d=%d\n″，d) ；
}
程序的运行结果如下：
c=15
d=-32768
程序中开辟了名为a 、b 、c 、d 的4个存储单元，它们在内存中各占两个字节。a 和b 所代表的存储单元存放10和5，c 所代表的存储单元中存放a 和b 中值的和15，d 中存放32767与1的和，由于受到int 型变量取值范围的限制，d 中存放的值为-32768，而不是32768。 从图6-2可以看到32767在内存中以二进制的表示形式，最左边一位是符号位(0表示正，1表示负) 。32767再加1后，右边15个二进制位全为0，最左边一位为1，它是-32768
的补码形式(数据在内存中都是以补码形式存放的) 。所以，最终输出的值为-32768。
因此，在使用某类型变量时，一定要注意该变量的取值范围。
---------------------------------------------------------------------------------------------------------------------------------------------
浮点型常量
浮点型常量有多种写法。其基本形式为：首先写整数部分（可以带符号），接着写小数
部分，然后写 e 或者 E ，最后再写一个有符号整数。例如：
+1.2E+5
1.5e-9
-5.0e10
其中 e 或 E 被称为阶码标志，e 或 E 后面的有符号整数被称为阶码。阶码代表 10 的阶码次方。例如：+1.2E+5 的值是 1.2 * 105。假设 A 为 e 前面的部分，N 是 e 后面的部分，则 AeN 等于 A * 10N。此外，正号可以省略不写。小数部分也不是必需的，也就是说，5e3 也是正确的。阶码标志和阶码也可以不写，如：13.5。小数点后面，阶码标志之前的那部分整数可以不写（9.E5），小数点之前的整数也可以不写（.96e-8），但是不能同时都不写。例如：
56.
.5
3.14
3e6
.6E-8
注意：浮点型常量中不能有空格！例如：
3.21e -12 /* 有空格，错！ */
3.14e5 /* 有空格，错！ */
浮点型常量默认是 double 类型的。假设 var_f 是 float 类型的变量，如果有以下语句： var_f = 9.0 * 3.0;
那么 9.0 和 3.0 都是 double 类型的常量。它们的乘积也是 double 型的。在进行赋
值的时候，这个乘积被转化成 float 类型，然后再赋值给 var_f。
当然，我们也可以指定浮点型常量的类型。在浮点型常量后面添上 f 或者 F ，编译器就会用 float 类型来处理这个常量。例如：1.5f ，2.1e6F 。在后面添上 l 或者 L 的话，编译器会用 long double 类型来处理这个常量。例如：4.1l ，50.2E5L 。最好用大写 L ，因为小写 l 容易和数字 1 混淆。
标准规定，对于 float 型，E 后面的阶码的取值范围至少要达到 -37 到 +37。对 double 和 long double 的规定同样如此。
C99 新增了一种表示浮点型常量的格式：使用十六进制前缀（0x 或 0X ，0 是数字 0，不是字母 o ），用 p 或 P 代替前面所说的 e 或 E ，而且阶码代表的是 2 的阶码次方。例如：
0xb.1ep5
其中 b 等于十进制中的 11, .1e 等于 1/16 加 14/256, p5 等于 25，也就是 512。这
个浮点型常量转换成十进制就是：(11 + 1/16 +14/256)*25 = 5692
---------------------------------------------------------------------------------------------------------------------------------------- 浮点型数据(float,double,logn double)介绍
1. float, double, 以及 long double
前面所说的数据类型只能用于处理整数。如果我们需要使用小数，就要使用浮点类型（floating-point ）。C 提供了三种浮点类型：float, double, 以及 long double 。注意，unsigned/signed 不能用于修饰浮点类型。浮点类型可以处理正数，也能处理负数。没有无符号浮点型。
C 标准要求 float 类型至少要能精确表示到小数点后6位。float 一般是 32 位的。
C 标准规定 double 类型至少要能精确到小数点后 10 位。double 通常是 64 位的。
C 还提供了 long double 类型，目的是提供一种比 double 更加精确的类型。然而，C 标准仅仅规定 long double 至少要和 double 一样精确。long double 通常 96 位或者 128 位。
2. 声明浮点型变量
浮点型变量的声明和初始化与整型变量一样。例如：
float f_1, f_2;
double d_1;
float f_3 = 6.63;
long double ld_1;
1 混淆。
标准规定，对于 float 型，E 后面的阶码的取值范围至少要达到 -37 到 +37。对 double 和 long double 的规定同样如此。
C99 新增了一种表示浮点型常量的格式：使用十六进制前缀（0x 或 0X ，0 是数字 0，不是字母 o ），用 p 或 P 代替前面所说的 e 或 E ，而且阶码代表的是 2 的阶码次方。例如：
0xb.1ep5
其中 b 等于十进制中的 11, .1e 等于 1/16 加 14/256, p5 等于 25，也就是 512。这个浮点型常量转换成十进制就是：(11 + 1/16 + 14/256)*25 = 5692
注意：并非所有编译器都支持 C99 新增的这种格式！
4. 输出浮点数
格式限定符 %f 命令 printf 函数以十进制形式输出 float 和 double 类型的浮点数；%e 命令 printf 函数以指数形式输出float 和 double 类型的浮点数；%a 或 %A 命令 printf 函数以 C99 新增的那种十六进制格式输出，但是并非所有编译器都支持。如果您要输出 long double 类型的浮点数，请用 %Lf， %Le，%La，或者 %LA。例如：
/* showfloat.c – 用两种形式表示浮点数 */
#include
int main(void)
{
float var_f = 5.0;
double var_df = 3.14e2;
long double var_ld = 6.51e-5;
printf("%f is equal to %e ", var_f, var_f);
printf("%f is equal to %e ", var_df, var_df);
printf("%Lf is equal to %Le ", var_ld, var_ld);
return 0;
}
输出如下:
5.000000 is equal to 5.000000e+00
314.000000 is equal to 3.140000e+02
0.000065 is equal to 6.510000e-05
注意：以上是我在 Suse Linux 10 下使用 gcc 4.02 编译运行得到的输出。如果使用 Dev-C++
4.9.9.2 编译运行本程序，则不能正常输出 var_ld。大概是因为 Dev-C++ 使用的编译器 gcc 中，long double 是 96 位的，而它使用函数库中的 printf 函数却把 long double 当作 64 位的来处理。
5. 浮点数上溢（Overflow ）和下溢（Underflow ）
假设您的编译器中，float 最大只能达到 3.4e38，如果有以下语句：
float toobig = 3.4E38 * 100.0f;
printf("%e ", toobig);
这必然导致上溢！因为 toobig 无法表示 3.4E38 和 100.0f 的乘积。上溢的后果过去是没有定义的，不过现在 C 规定如果发生上溢，则产生一个表示无穷大的特殊值。因此，toobig 的值最终会变成一个表示无穷大的特殊值。进而，printf 函数会输出类似 inf 或者 infinity 的字眼。
对一个绝对值非常小的浮点数进行除法，并且导致这个浮点数的精度降低，称之为下溢。打个比方，假设 3.1415e-10 除以 10 后，变成 0.3141e-10，这就是下溢。
单精度浮点型（float ） 在C++中，单精度浮点型（float ）专指占用32位存储空间的单精度（single-precision ）值。单精度在一些处理器上比双精度更快而且只占用双精度一半的空间，但是当值很大或很小的时候，它将变得不精确。当你需要小数部分并且对精度的要求不
高时，单精度浮点型的变量是有用的。例如，当表示美元和分时，单精度浮点型是有用的。 在foxpro 中，单精度浮点型是为了提供兼容性, 浮点数据类型在功能上等价于数值型。 在VB 中，Single 数据类型 Single （单精度浮点型）变量存储为 IEEE 32 位（4 个字节）浮点数值的形式，它的范围在负数的时候是从 -3.402823E38 到 -1.401298E-45，而在正数的时候是从 1.401298E-45 到 3.402823E38。6位有效位数 Single 的类型声明字符为感叹号 (!)。
6. 浮点型的选用
通常，double 是最好的选择，因为其精度较高，而且导致的运行时耗费相对 float 也多不了多少。
双精度浮点型定义 类型---double float 数据类型，计算机中表示实型变量的一种变量类型。
此数据类型与单精度数据类型(float)相似，但精确度比float 高，编译时所占的内存空间依不同的编译器而有所不同，通常情况，单精度浮点数占4字节（32位）内存空间，其数值范围为
3.4E-38～3.4E+38,；双精度型占8 个字节（64位）内存空间，其数值范围为1.7E-308～1.7E+308。 声明double 类型的变量： double puotient; 初始化double 类型的变量： puotient = 5.621456873; double puotinet = 5.12; 2双精度浮点型概括 C 语言中, 双精度浮点(double)型，占8 个字节（64位）内存空间。其数值范围为1.7E-308～1.7E+308，双精度完全保证的有效数字是15位，16位只是部分数值有保证，而单精度保证7位有效数字，部分数值有8位有效数. 浮点型从狭义上说就是科学记数法 双精度，即 double 。 double 有二，两个的意思。 C 标准要求 float 类型至少要能精确表示到小数点后6位，并且整数部分的表示范围至少要达到 10-37 -- 10+37 。float 一般是 32 位的。 C 标准规定double 类型的整数部分的最小表示范围和 float 一样，都是 10-37 到 10+37，但是它要求 double 类型的小数部分至少要能精确到小数点后 10 位。double 通常是 64 位的。 long double C 还提供了 long double 类型，目的是提供一种比 double 更加精确的类型。 然而，C 标准仅仅规定 long double 至少要和 double 一样精确。 ---------------------------------------------------------------------------------------------------------------------------------------------
字符常量
字符常量是用单引号括起来的单个字符构成。
有两种表示方法:
一种是用该字符的图形符号，如'b' ，'y' ，'*'。
另外还可以用字符的ASCII 码表示，即用反斜符(\)开头，后跟字符的ASCII 码，这种方法也称为转义序列表示法，具体方法是:有两种形式：
一种是用字符的八进制ASCII 码，表示为：\odd.这里，odd 是八进制值（o 可以省略）。 另一种使用字符的十六进制ASCII 码值，表示为 \0xhh或0Xhh 这里hh 是两位十六进制值。
如：'A' ，'\101' 和 '\x41' 都表示同一个字符常量。
转义序列表示法还可以用来表示一些特殊字符，用来显示特殊符号或控制输出格式。 在C 语言中，字符常量有以下特点：
1) 字符常量只能用单引号括起来，不能用双引号或其它括号。
2) 字符常量只能是单个字符，不能是字符串。
3) 字符可以是字符集中任意字符。但数字被定义为字符型之后就不能参与数值运算。如'5' 和5 是不同的。'5' 是字符常量，不能参与运算。
2C 语言
在C 语言中，一个字符常量代表ASCII 字符集中的一个字符，在程序中用单引号把一个ASCII 字符集中的字符括起来作为字符常量。
字符常量在内存中占一个字节，存放的是字符的ASCII 码（整型数据）。C 语言规定所有字符常量都作为整型量来处理。
1含义
字符串常量是一对双引号括起来的字符序列。
例如下面的是合法的字符串常量: "how do you do.","CHINA","a","$123.45"
存储：字符串中的字符依次存储在内存中一块连续的区域内，并且把空字符„ \0‟自动附加到字符串的尾部作为字符串的结束标志。故字符个数为n 的字符串在内存中应占（n+1）个字节。
可以输出字符串，例如：
printf("how do you do.");
2与字符常量的比较
C 语言允许使用字符串常量外，还允许使用字符常量。字符常量是由一对单引号括起来的单个字符。
不能将字符串与字符常量混淆。字符常量可以赋值给字符变量，如"char b='a';",但不能把一个字符串常量赋给一个字符变量, 同时也不能对字符串常量赋值！
3与字符数组的关系
在C 语言中没有专门的字符串变量，如果想将一个字符串存放在变量中以便保存，必须使用字符数组，即用一个字符型数组来存放一个字符串，数组中每一个元素存放一个字符。例如“char a[10]="love".”
--------------------------------------------------------------------------------------------------------------------------------------
字符变量
定义形式： char 标识符1，标识符2，… ，标识符n
例如： char c1, c2, c3, ch ;
c1=„a‟ ; c2=„b‟ ; c3=„c‟ ; ch=„ d‟ ;
说明：
1. 字符变量在内存中占一个字节。
2. 在内存中, 是把字符对应的ASCII 码值放到存储单元中.
3. 字符型数据与整型数据之间可以通用.
每个字符变量被分配一个字节的的内存空间，因此只能存放一个字符。字符值是以ASC Ⅱ码的形式存放在变量的内存单元之中的。如x 的十进制ASC Ⅱ是120，y 的十进制ASC Ⅱ是121。对字符变量a ，b 赋予'x' 和'y' 值：a='x';b='y';实际上是在a,b 两个单元内存放120和121的二进制代码：
a 01111000
b 01111001
所以也可以把它们看成是整形变量。C 语言允许对整形变量赋予字符值，也允许对字符变量赋整形值。在输出时，允许把字符变量按整形量输出，也允许把整形量按字符量输出。整形量为二字节量，字符量为单字节量，当整形量按字符量处理时，只有低八位字节参与处理。
------------------------------------------------------------------------------------------------------------------------------------------
枚举型常量与变量
枚举型
枚举型数据是ANSIC 新标准中提供的一种用户自定义的数据类型，主要用途是用名称来代替某些有特定含义的数据，增加程序的可读性。
枚举型的定义
枚举型需要用户自己定义，定义方法如下：
enum 枚举型名
{枚举常量1，枚举常量2,…，枚举常量n};
注意在右花括号的后面有一个语句结束符“分号”。其中：枚举型名是用户取的标识符；枚举常量是用户给常量取的标识符。
该语句定义了一个名为“枚举型名”的枚举类型，该枚举型中含有n 个枚举常量，每个枚举常量均有值。C 语言规定枚举常量的值是依次等于0、1、…、n-l 。
例如，定义一个表示星期的枚举型：
enum week
{sun,mon,tue,wed,thu,fri,sat};
定义的这个枚举型共有7个枚举常量，它们的值依次为0、1、2、3、4、5、6。
C 语言规定，在定义枚举型时，可以给枚举常量赋初值，方法是在枚举常量的后面跟上“=整型
常量”。例如，表示三原色的枚举型可以定义如下： enum colorl
{red=2,yellow=4,blue=7};
则枚举常量，red 的值为2,yellow 的值为4,blue 的值为7。
C 语言还规定，在给枚举常量赋初值时，如果给其中任何一个枚举常量赋初值，则其后的枚举常量将按自然数的规则依次赋初值，请看下例：
enuln weekl
{sun,mon,tue=5,wed,thu,fri,sat};
则枚举常量的初值如下：sun 值为0，mon 值为1,tue 值为5, wed值为6,thu 值为7，fri 值为8,sat 值为9。
枚举型变量的定义
当某个枚举型定义后，可以用这种枚举型来定义变量、数组。定义的方法有三种：
1、先定义枚举型，后定义枚举型变量、数组，请看下例。
enum color
{red,yellow,blue};
enum color color_1,color_[2];
2、定义枚举型的同时定义枚举型变量、数组，请看下例。
enum color
{red,yellow,blue} color_l,color_2[2];
3、定义无名称的枚举型同时定义枚举型变量、数组，请看下例。
enlll color {red,yellow,blue} color_1,color_2[2];
枚举型变量的引用
枚举型变量或数组元素的引用方法就是变量名或数组元素名。
枚举型变量或数组元素的使用只能是下列几种情况。
1、给变量或数组元素赋值，格式为：枚举型变量或数组元素＝同一种枚举型常量名
C 语言规定，虽然枚举常量值是0或自然数，但是不能直接将整型常量赋予枚举型变量或数组元素。但是可以通过类型强制转换来赋值，请看下面的程序段。
enum color
{red,yellow,blue}c_l;
cl=yellow; /*正确，将值为1的枚举常量yellow 赋予枚举型变量c_1*/
c_l=1; /*错误，不能直接将整型常量赋予枚举型变量*/
c_l=(enum color)l; /*正确，先将l 强制转换成枚举型常量yellow 再赋值*/
重要说明：有少数的C 编译系统允许将整型常量直接赋予枚举型变量，例如Turho C。所以
使用Turbo C编译系统编译上述程序，其中的语句“c_1=l;”并不会出错。
2、用比较运算符对两个枚举型变量或数组元素进行“大小”的比较，比较时可以按照变量或数组元素的枚举型常量值(整数) 的大小进行。
3、在循环中用枚举变量或数组元素控制循环。
整型常量
1. 八进制整常数
八进制整常数必须以0开头，即以0作为八进制数的前缀。数码取值为0～7。八进制数通常是无符号数。 以下各数是合法的八进制数：
015(十进制为13) 0101(十进制为65) 0177777(十进制为65535)
以下各数不是合法的八进制数：
256(无前缀0) 03A2(包含了非八进制数码) -0127(出现了负号)
2. 十六进制整常数
十六进制整常数的前缀为0X 或0x 。其数码取值为0~9，A~F或a~f。
以下各数是合法的十六进制整常数：
0X2A(十进制为42) 0XA0 (十进制为160) 0XFFFF (十进制为65535)
以下各数不是合法的十六进制整常数：
5A (无前缀0X) 0X3H (含有非十六进制数码)
3. 十进制整常数
十进制整常数没有前缀。其数码为0～9。
以下各数是合法的十进制整常数：
237 -568 65535 1627
以下各数不是合法的十进制整常数：
023 (不能有前导0) 23D (含有非十进制数码)
在程序中是根据前缀来区分各种进制数的。因此在书写常数时不要把前缀弄错造成结果不正确。
4. 整型常数的后缀
在16位字长的机器上，基本整型的长度也为16位，因此表示的数的范围也是有限定的：
十进制无符号整常数的范围为0～65535，有符号数为-32768～+32767。
八进制无符号数的表示范围为0～0177777。
十六进制无符号数的表示范围为0X0～0XFFFF 或0x0～0xFFFF 。
如果使用的数超过了上述范围，就必须用长整型数来表示。长整型数是用后缀“L”或“l”来表示的。例如： 十进制长整常数 158L (十进制为158) 358000L (十进制为-358000)
八进制长整常数 012L (十进制为10) 077L (十进制为63) 0200000L (十进制为65536)
十六进制长整常数 0X15L (十进制为21) 0XA5L (十进制为165) 0X10000L (十进制为65536)
长整数158L 和基本整常数158 在数值上并无区别。但对158L ，因为是长整型量，Ｃ编译系统将为它分配4个字节存储空间。而对158，因为是基本整型，只分配2 个字节的存储空间。因此在运算和输出格式上要予以注意，避免出错。无符号数也可用后缀表示，整型常数的无符号数的后缀为“U”或“u”。例如： 358u,0x38Au,235Lu 均为无符号数。前缀，后缀可同时使用以表示各种类型的数。如0XA5Lu 表示十六进制无符号长整数A5，其十进制为165。
整型变量 1. 分类
整型变量可以分为以下4类：
(1)短整型，类型关键字为short[int]。
类型说明符为short int或short'C110F1。所占字节和取值范围会因不同的编译系统而有差异。对于16字机，short int 占2个字节，在大多数的32位机中，short int 占4个字节。但总的来说，short int 至少16位，也就是2个字节。
(2)基本整型，类型关键字为int 。
类型说明符为int ，在内存中占4个字节（不同系统可能有差异，此处原为2，经查证windows 系统下为4，VAX 系统也如此） ，其取值为基本整常数
(3)长整型，类型关键字为long[int]。
类型说明符为long int或long ，在内存中占4个字节，其取值为长整常数。在任何的编译系统中，长整型都是占4个字节。在一般情况下，其所占的字节数和取值范围与基本型相同。 (4)无符号整型，类型关键字为unsigned[int]或unsignedshort 或unsignedlong 。
unsigned[int]表示无符号基本整型；
unsignedshort 表示无符号短整型；
unsignedlong 表示无符号长整型。
无符号整型只能用来存储无符号整数。
类型说明符为unsigned 。在编译系统中，系统会区分有符号数和无符号数，区分的根据是如何解释字节中的最高位，如果最高位被解释为数据位，则整型数据则表示为无符号数
无符号型
各种无符号类型量所占的内存空间字节数与相应的有符号类型量相同。但由于省去了符号位，故不能表示负数。 下表列出了Turbo C中各类整型量所分配的内存字节数及数的表示范围。
类型说明符 数的范围 分配字节数
int -32768~32767
short int -32768~32767
signed int -32768~32767
unsigned int 0~65535
long int -2147483648~2147483647
unsigned long 0~4294967295
变量说明的一般形式为
类型说明符 变量名标识符，变量名标识符，...;
例如
int a,b,c; (a,b,c为整型变量)
long x,y; (x,y为变量)
unsigned p,q; (p,q为无符号整型变量)
定义整型变量的格式是
整数类型 1个变量名或用逗号格开的多个变量名
类似地，还可以定义 unsigned int 、 unsigned long 型的变量。
定义一个变量，意味着在内存中给这个变量分配了相应大小的存储空间，同时确定了这个变量值的存储方式和可以进行的操作
2. 占用内存字节数与值域
上述各类型的整型变量占用的内存字节数随系统而异，一般以一个机器字(word)存放一个int 型数据，而long 型数据的字节数应不小于int 型，short 型不长于int 型。在16位
操作系统(例如DOS) 中，一般用2字节存放一个int 型数据；在32位操作系统(例如Win-dows98) 中，默认为4字节。
本节选用16位系统，各类整型数据的存储情况及取值范围如表6-1所示。
显然，不同类型的整型变量，其值域不同。占用内存字节数为n 的有符号整型变量，其值域为-2n*8-1 ～2n*8-1-1; 无符号整型变量的值域为0～2n*8 -1。例如,16位操作系统中
的一个int 型变量，其值域为-22*8-1～22*8-1-1, 即-32 768～32 767；一个unsigned 型变量的值域为0～2 2*8 -1，即0～65535。
【例6.1】 整型数据程序示例。
main()
{inta，b ，c ，d ；
a=10，b=5；
c=a+b；
d=32767+1；
printf(″c=%d\n″，c) ；
printf(″d=%d\n″，d) ；
}
程序的运行结果如下：
c=15
d=-32768
程序中开辟了名为a 、b 、c 、d 的4个存储单元，它们在内存中各占两个字节。a 和b 所代表的存储单元存放10和5，c 所代表的存储单元中存放a 和b 中值的和15，d 中存放32767与1的和，由于受到int 型变量取值范围的限制，d 中存放的值为-32768，而不是32768。 从图6-2可以看到32767在内存中以二进制的表示形式，最左边一位是符号位(0表示正，1表示负) 。32767再加1后，右边15个二进制位全为0，最左边一位为1，它是-32768
的补码形式(数据在内存中都是以补码形式存放的) 。所以，最终输出的值为-32768。
因此，在使用某类型变量时，一定要注意该变量的取值范围。
---------------------------------------------------------------------------------------------------------------------------------------------
浮点型常量
浮点型常量有多种写法。其基本形式为：首先写整数部分（可以带符号），接着写小数
部分，然后写 e 或者 E ，最后再写一个有符号整数。例如：
+1.2E+5
1.5e-9
-5.0e10
其中 e 或 E 被称为阶码标志，e 或 E 后面的有符号整数被称为阶码。阶码代表 10 的阶码次方。例如：+1.2E+5 的值是 1.2 * 105。假设 A 为 e 前面的部分，N 是 e 后面的部分，则 AeN 等于 A * 10N。此外，正号可以省略不写。小数部分也不是必需的，也就是说，5e3 也是正确的。阶码标志和阶码也可以不写，如：13.5。小数点后面，阶码标志之前的那部分整数可以不写（9.E5），小数点之前的整数也可以不写（.96e-8），但是不能同时都不写。例如：
56.
.5
3.14
3e6
.6E-8
注意：浮点型常量中不能有空格！例如：
3.21e -12 /* 有空格，错！ */
3.14e5 /* 有空格，错！ */
浮点型常量默认是 double 类型的。假设 var_f 是 float 类型的变量，如果有以下语句： var_f = 9.0 * 3.0;
那么 9.0 和 3.0 都是 double 类型的常量。它们的乘积也是 double 型的。在进行赋
值的时候，这个乘积被转化成 float 类型，然后再赋值给 var_f。
当然，我们也可以指定浮点型常量的类型。在浮点型常量后面添上 f 或者 F ，编译器就会用 float 类型来处理这个常量。例如：1.5f ，2.1e6F 。在后面添上 l 或者 L 的话，编译器会用 long double 类型来处理这个常量。例如：4.1l ，50.2E5L 。最好用大写 L ，因为小写 l 容易和数字 1 混淆。
标准规定，对于 float 型，E 后面的阶码的取值范围至少要达到 -37 到 +37。对 double 和 long double 的规定同样如此。
C99 新增了一种表示浮点型常量的格式：使用十六进制前缀（0x 或 0X ，0 是数字 0，不是字母 o ），用 p 或 P 代替前面所说的 e 或 E ，而且阶码代表的是 2 的阶码次方。例如：
0xb.1ep5
其中 b 等于十进制中的 11, .1e 等于 1/16 加 14/256, p5 等于 25，也就是 512。这
个浮点型常量转换成十进制就是：(11 + 1/16 +14/256)*25 = 5692
---------------------------------------------------------------------------------------------------------------------------------------- 浮点型数据(float,double,logn double)介绍
1. float, double, 以及 long double
前面所说的数据类型只能用于处理整数。如果我们需要使用小数，就要使用浮点类型（floating-point ）。C 提供了三种浮点类型：float, double, 以及 long double 。注意，unsigned/signed 不能用于修饰浮点类型。浮点类型可以处理正数，也能处理负数。没有无符号浮点型。
C 标准要求 float 类型至少要能精确表示到小数点后6位。float 一般是 32 位的。
C 标准规定 double 类型至少要能精确到小数点后 10 位。double 通常是 64 位的。
C 还提供了 long double 类型，目的是提供一种比 double 更加精确的类型。然而，C 标准仅仅规定 long double 至少要和 double 一样精确。long double 通常 96 位或者 128 位。
2. 声明浮点型变量
浮点型变量的声明和初始化与整型变量一样。例如：
float f_1, f_2;
double d_1;
float f_3 = 6.63;
long double ld_1;
1 混淆。
标准规定，对于 float 型，E 后面的阶码的取值范围至少要达到 -37 到 +37。对 double 和 long double 的规定同样如此。
C99 新增了一种表示浮点型常量的格式：使用十六进制前缀（0x 或 0X ，0 是数字 0，不是字母 o ），用 p 或 P 代替前面所说的 e 或 E ，而且阶码代表的是 2 的阶码次方。例如：
0xb.1ep5
其中 b 等于十进制中的 11, .1e 等于 1/16 加 14/256, p5 等于 25，也就是 512。这个浮点型常量转换成十进制就是：(11 + 1/16 + 14/256)*25 = 5692
注意：并非所有编译器都支持 C99 新增的这种格式！
4. 输出浮点数
格式限定符 %f 命令 printf 函数以十进制形式输出 float 和 double 类型的浮点数；%e 命令 printf 函数以指数形式输出float 和 double 类型的浮点数；%a 或 %A 命令 printf 函数以 C99 新增的那种十六进制格式输出，但是并非所有编译器都支持。如果您要输出 long double 类型的浮点数，请用 %Lf， %Le，%La，或者 %LA。例如：
/* showfloat.c – 用两种形式表示浮点数 */
#include
int main(void)
{
float var_f = 5.0;
double var_df = 3.14e2;
long double var_ld = 6.51e-5;
printf("%f is equal to %e ", var_f, var_f);
printf("%f is equal to %e ", var_df, var_df);
printf("%Lf is equal to %Le ", var_ld, var_ld);
return 0;
}
输出如下:
5.000000 is equal to 5.000000e+00
314.000000 is equal to 3.140000e+02
0.000065 is equal to 6.510000e-05
注意：以上是我在 Suse Linux 10 下使用 gcc 4.02 编译运行得到的输出。如果使用 Dev-C++
4.9.9.2 编译运行本程序，则不能正常输出 var_ld。大概是因为 Dev-C++ 使用的编译器 gcc 中，long double 是 96 位的，而它使用函数库中的 printf 函数却把 long double 当作 64 位的来处理。
5. 浮点数上溢（Overflow ）和下溢（Underflow ）
假设您的编译器中，float 最大只能达到 3.4e38，如果有以下语句：
float toobig = 3.4E38 * 100.0f;
printf("%e ", toobig);
这必然导致上溢！因为 toobig 无法表示 3.4E38 和 100.0f 的乘积。上溢的后果过去是没有定义的，不过现在 C 规定如果发生上溢，则产生一个表示无穷大的特殊值。因此，toobig 的值最终会变成一个表示无穷大的特殊值。进而，printf 函数会输出类似 inf 或者 infinity 的字眼。
对一个绝对值非常小的浮点数进行除法，并且导致这个浮点数的精度降低，称之为下溢。打个比方，假设 3.1415e-10 除以 10 后，变成 0.3141e-10，这就是下溢。
单精度浮点型（float ） 在C++中，单精度浮点型（float ）专指占用32位存储空间的单精度（single-precision ）值。单精度在一些处理器上比双精度更快而且只占用双精度一半的空间，但是当值很大或很小的时候，它将变得不精确。当你需要小数部分并且对精度的要求不
高时，单精度浮点型的变量是有用的。例如，当表示美元和分时，单精度浮点型是有用的。 在foxpro 中，单精度浮点型是为了提供兼容性, 浮点数据类型在功能上等价于数值型。 在VB 中，Single 数据类型 Single （单精度浮点型）变量存储为 IEEE 32 位（4 个字节）浮点数值的形式，它的范围在负数的时候是从 -3.402823E38 到 -1.401298E-45，而在正数的时候是从 1.401298E-45 到 3.402823E38。6位有效位数 Single 的类型声明字符为感叹号 (!)。
6. 浮点型的选用
通常，double 是最好的选择，因为其精度较高，而且导致的运行时耗费相对 float 也多不了多少。
双精度浮点型定义 类型---double float 数据类型，计算机中表示实型变量的一种变量类型。
此数据类型与单精度数据类型(float)相似，但精确度比float 高，编译时所占的内存空间依不同的编译器而有所不同，通常情况，单精度浮点数占4字节（32位）内存空间，其数值范围为
3.4E-38～3.4E+38,；双精度型占8 个字节（64位）内存空间，其数值范围为1.7E-308～1.7E+308。 声明double 类型的变量： double puotient; 初始化double 类型的变量： puotient = 5.621456873; double puotinet = 5.12; 2双精度浮点型概括 C 语言中, 双精度浮点(double)型，占8 个字节（64位）内存空间。其数值范围为1.7E-308～1.7E+308，双精度完全保证的有效数字是15位，16位只是部分数值有保证，而单精度保证7位有效数字，部分数值有8位有效数. 浮点型从狭义上说就是科学记数法 双精度，即 double 。 double 有二，两个的意思。 C 标准要求 float 类型至少要能精确表示到小数点后6位，并且整数部分的表示范围至少要达到 10-37 -- 10+37 。float 一般是 32 位的。 C 标准规定double 类型的整数部分的最小表示范围和 float 一样，都是 10-37 到 10+37，但是它要求 double 类型的小数部分至少要能精确到小数点后 10 位。double 通常是 64 位的。 long double C 还提供了 long double 类型，目的是提供一种比 double 更加精确的类型。 然而，C 标准仅仅规定 long double 至少要和 double 一样精确。 ---------------------------------------------------------------------------------------------------------------------------------------------
字符常量
字符常量是用单引号括起来的单个字符构成。
有两种表示方法:
一种是用该字符的图形符号，如'b' ，'y' ，'*'。
另外还可以用字符的ASCII 码表示，即用反斜符(\)开头，后跟字符的ASCII 码，这种方法也称为转义序列表示法，具体方法是:有两种形式：
一种是用字符的八进制ASCII 码，表示为：\odd.这里，odd 是八进制值（o 可以省略）。 另一种使用字符的十六进制ASCII 码值，表示为 \0xhh或0Xhh 这里hh 是两位十六进制值。
如：'A' ，'\101' 和 '\x41' 都表示同一个字符常量。
转义序列表示法还可以用来表示一些特殊字符，用来显示特殊符号或控制输出格式。 在C 语言中，字符常量有以下特点：
1) 字符常量只能用单引号括起来，不能用双引号或其它括号。
2) 字符常量只能是单个字符，不能是字符串。
3) 字符可以是字符集中任意字符。但数字被定义为字符型之后就不能参与数值运算。如'5' 和5 是不同的。'5' 是字符常量，不能参与运算。
2C 语言
在C 语言中，一个字符常量代表ASCII 字符集中的一个字符，在程序中用单引号把一个ASCII 字符集中的字符括起来作为字符常量。
字符常量在内存中占一个字节，存放的是字符的ASCII 码（整型数据）。C 语言规定所有字符常量都作为整型量来处理。
1含义
字符串常量是一对双引号括起来的字符序列。
例如下面的是合法的字符串常量: "how do you do.","CHINA","a","$123.45"
存储：字符串中的字符依次存储在内存中一块连续的区域内，并且把空字符„ \0‟自动附加到字符串的尾部作为字符串的结束标志。故字符个数为n 的字符串在内存中应占（n+1）个字节。
可以输出字符串，例如：
printf("how do you do.");
2与字符常量的比较
C 语言允许使用字符串常量外，还允许使用字符常量。字符常量是由一对单引号括起来的单个字符。
不能将字符串与字符常量混淆。字符常量可以赋值给字符变量，如"char b='a';",但不能把一个字符串常量赋给一个字符变量, 同时也不能对字符串常量赋值！
3与字符数组的关系
在C 语言中没有专门的字符串变量，如果想将一个字符串存放在变量中以便保存，必须使用字符数组，即用一个字符型数组来存放一个字符串，数组中每一个元素存放一个字符。例如“char a[10]="love".”
--------------------------------------------------------------------------------------------------------------------------------------
字符变量
定义形式： char 标识符1，标识符2，… ，标识符n
例如： char c1, c2, c3, ch ;
c1=„a‟ ; c2=„b‟ ; c3=„c‟ ; ch=„ d‟ ;
说明：
1. 字符变量在内存中占一个字节。
2. 在内存中, 是把字符对应的ASCII 码值放到存储单元中.
3. 字符型数据与整型数据之间可以通用.
每个字符变量被分配一个字节的的内存空间，因此只能存放一个字符。字符值是以ASC Ⅱ码的形式存放在变量的内存单元之中的。如x 的十进制ASC Ⅱ是120，y 的十进制ASC Ⅱ是121。对字符变量a ，b 赋予'x' 和'y' 值：a='x';b='y';实际上是在a,b 两个单元内存放120和121的二进制代码：
a 01111000
b 01111001
所以也可以把它们看成是整形变量。C 语言允许对整形变量赋予字符值，也允许对字符变量赋整形值。在输出时，允许把字符变量按整形量输出，也允许把整形量按字符量输出。整形量为二字节量，字符量为单字节量，当整形量按字符量处理时，只有低八位字节参与处理。
------------------------------------------------------------------------------------------------------------------------------------------
枚举型常量与变量
枚举型
枚举型数据是ANSIC 新标准中提供的一种用户自定义的数据类型，主要用途是用名称来代替某些有特定含义的数据，增加程序的可读性。
枚举型的定义
枚举型需要用户自己定义，定义方法如下：
enum 枚举型名
{枚举常量1，枚举常量2,…，枚举常量n};
注意在右花括号的后面有一个语句结束符“分号”。其中：枚举型名是用户取的标识符；枚举常量是用户给常量取的标识符。
该语句定义了一个名为“枚举型名”的枚举类型，该枚举型中含有n 个枚举常量，每个枚举常量均有值。C 语言规定枚举常量的值是依次等于0、1、…、n-l 。
例如，定义一个表示星期的枚举型：
enum week
{sun,mon,tue,wed,thu,fri,sat};
定义的这个枚举型共有7个枚举常量，它们的值依次为0、1、2、3、4、5、6。
C 语言规定，在定义枚举型时，可以给枚举常量赋初值，方法是在枚举常量的后面跟上“=整型
常量”。例如，表示三原色的枚举型可以定义如下： enum colorl
{red=2,yellow=4,blue=7};
则枚举常量，red 的值为2,yellow 的值为4,blue 的值为7。
C 语言还规定，在给枚举常量赋初值时，如果给其中任何一个枚举常量赋初值，则其后的枚举常量将按自然数的规则依次赋初值，请看下例：
enuln weekl
{sun,mon,tue=5,wed,thu,fri,sat};
则枚举常量的初值如下：sun 值为0，mon 值为1,tue 值为5, wed值为6,thu 值为7，fri 值为8,sat 值为9。
枚举型变量的定义
当某个枚举型定义后，可以用这种枚举型来定义变量、数组。定义的方法有三种：
1、先定义枚举型，后定义枚举型变量、数组，请看下例。
enum color
{red,yellow,blue};
enum color color_1,color_[2];
2、定义枚举型的同时定义枚举型变量、数组，请看下例。
enum color
{red,yellow,blue} color_l,color_2[2];
3、定义无名称的枚举型同时定义枚举型变量、数组，请看下例。
enlll color {red,yellow,blue} color_1,color_2[2];
枚举型变量的引用
枚举型变量或数组元素的引用方法就是变量名或数组元素名。
枚举型变量或数组元素的使用只能是下列几种情况。
1、给变量或数组元素赋值，格式为：枚举型变量或数组元素＝同一种枚举型常量名
C 语言规定，虽然枚举常量值是0或自然数，但是不能直接将整型常量赋予枚举型变量或数组元素。但是可以通过类型强制转换来赋值，请看下面的程序段。
enum color
{red,yellow,blue}c_l;
cl=yellow; /*正确，将值为1的枚举常量yellow 赋予枚举型变量c_1*/
c_l=1; /*错误，不能直接将整型常量赋予枚举型变量*/
c_l=(enum color)l; /*正确，先将l 强制转换成枚举型常量yellow 再赋值*/
重要说明：有少数的C 编译系统允许将整型常量直接赋予枚举型变量，例如Turho C。所以
使用Turbo C编译系统编译上述程序，其中的语句“c_1=l;”并不会出错。
2、用比较运算符对两个枚举型变量或数组元素进行“大小”的比较，比较时可以按照变量或数组元素的枚举型常量值(整数) 的大小进行。
3、在循环中用枚举变量或数组元素控制循环。