C语言的数据类型Word文档下载推荐.docx

C语言的数据类型Word文档下载推荐.docx

《C语言的数据类型Word文档下载推荐.docx》由会员分享，可在线阅读，更多相关《C语言的数据类型Word文档下载推荐.docx（17页珍藏版）》请在冰豆网上搜索。

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-568655351627

以下各数不是合法的十进制整常数：

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.基本型

类型说明符为int，在内存中占2个字节，其取值为基本整常数。

2.短整量

类型说明符为shortint或short'

C110F1。

所占字节和取值范围均与基本型相同。

3.长整型

类型说明符为longint或long，在内存中占4个字节，其取值为长整常数。

4.无符号型

类型说明符为unsigned。

无符号型又可与上述三种类型匹配而构成：

（1）无符号基本型类型说明符为unsignedint或unsigned。

（2）无符号短整型类型说明符为unsignedshort

（3）无符号长整型类型说明符为unsignedlong

各种无符号类型量所占的内存空间字节数与相应的有符号类型量相同。

但由于省去了符号位，故不能表示负数。

下表列出了TurboC中各类整型量所分配的内存字节数及数的表示范围。

类型说明符　　　　数的范围　　　　分配字节数

int　　　　　　-32768~32767　　　　■■

shortint　　　-32768~32767　　　　■■

signedint　　-32768~32767　　　　■■

unsignedint　0~65535　　　　　　■■

longint　-2147483648~2147483647　　■■■■

unsignedlong　0~4294967295　　　　■■■■

整型变量的说明

变量说明的一般形式为：

类型说明符变量名标识符，变量名标识符，...;

例如：

inta,b,c;

（a,b,c为整型变量）

longx,y;

（x,y为长整型变量）

unsignedp,q;

（p,q为无符号整型变量）

在书写变量说明时，应注意以下几点：

1.允许在一个类型说明符后，说明多个相同类型的变量。

各变量名之间用逗号间隔。

类型说明符与变量名之间至少用一个空格间隔。

2.最后一个变量名之后必须以“；

”号结尾。

3.变量说明必须放在变量使用之前。

一般放在函数体的开头部分。

[Practice]//1inta,b;

shortintc;

shortd=100;

a=d-20;

b=a+d;

c=a+b+d;

d=d-a+c-b;

'

Vtable

a,2,0

b,2,0

c,2,0

d,2,100

ofVtable

Vupdate

1,0;

2,0

3,0

4,100

1,80

2,180

3,360

4,200

ofVupdate

ofPractice

[Practice]//2inta=5;

intb=9;

longintc;

longd;

c=a+b-7;

d=a*b*c;

c=d*d*d;

a=c-d;

a,2,5

b,2,9

c,4,0

d,4,0

1,5

2,9

4,0

3,7

4,315

3,31255875

1,-5112

[Practice]//3inta=6,b=19;

unsignedintc;

intd;

c=a-b+7;

d=b*c;

a=b+c+d;

b=-a;

a,2,6

b,2,19

d,2,0

1,6;

2,19

3,65530

4,-114

1,-101

2,101

voidmain（）{

inta,b,c,d;

x=5;

y=6;

a=7;

b=8;

c=x+a;

d=y+b;

printf（"

c=x+a=%d,d=y+b=%d\n"

c,d）;

}

将main说明为返回void,即不返回任何类型的值

x,y被定义为long型

a,b,c,d被定义为int型

5->

x

6->

y

7->

a

8->

b

x+a->

c

y+b->

d

显示程序运行结果oflongx,y;

　　从程序中可以看到：

x,y是长整型变量，a,b是基本整型变量。

它们之间允许进行运算，运算结果为长整型。

但c，d被定义为基本整型，因此最后结果为基本整型。

本例说明，不同类型的量可以参与运算并相互赋值。

其中的类型转换是由编译系统自动完成的。

有关类型转换的规则将在以后介绍。

实型量

实型常量

实型也称为浮点型。

实型常量也称为实数或者浮点数。

在Ｃ语言中，实数只采用十进制。

它有二种形式：

十进制数形式指数形式

1.十进制数形式

由数码0~9和小数点组成。

0.0，.25，5.789，0.13，5.0，300.，-267.8230等均为合法的实数。

2.指数形式

由十进制数，加阶码标志“e”或“E”以及阶码（只能为整数，可以带符号）组成。

其一般形式为aEn（a为十进制数，n为十进制整数）其值为a*10,n　如：

2.1E5（等于2.1*10,5）,3.7E-2（等于3.7*10,）-2*）　0.5E7（等于0.5*10,7）,-2.8E-2（等于-2.8*10,）-2*）以下不是合法的实数345（无小数点）　E7（阶码标志E之前无数字）　-5（无阶码标志）　53.-E3（负号位置不对）　2.7E（无阶码）

标准Ｃ允许浮点数使用后缀。

后缀为“f”或“F”即表示该数为浮点数。

如356f和356.是等价的。

例2.2说明了这种情况：

voidmain（）

{

%f\n%f\n"

356.,356f）;

void指明main不返回任何值　利用printf显示结果　结束

实型变量

实型变量分为两类：

单精度型和双精度型，

其类型说明符为float单精度说明符，double双精度说明符。

在TurboC中单精度型占4个字节（32位）内存空间，其数值范围为3.4E-38～3.4E+38，只能提供七位有效数字。

双精度型占8个字节（64位）内存空间，其数值范围为1.7E-308～1.7E+308，可提供16位有效数字。

实型变量说明的格式和书写规则与整型相同。

floatx,y;

（x,y为单精度实型量）

　　　doublea,b,c;

（a,b,c为双精度实型量）

实型常数不分单、双精度，都按双精度double型处理。

floata;

doubleb;

a=33333.33333;

b=33333.33333333333333;

a,b）;

此程序说明float、double的不同

a■■■■

b■■■■■■■■

a<

---33333.33333

b<

---33333.33333333333;

;

显示程序结果

从本例可以看出，由于a是单精度浮点型，有效位数只有七位。

而整数已占五位，故小数二位后之后均为无效数字。

b是双精度型，有效位为十六位。

但TurboC规定小数后最多保留六位，其余部分四舍五入。

[Practice]//floatinta=32;

floatb;

doubled;

b=12345678;

d=b*100;

d=d+a;

d=d+58.123456;

a,2,32

b,4,0.0

d,8,0.0

1,32

2,12345678.00000

3,1234567800

3,1234567832

3,1234567890.123456

[Practice]//1inta=543;

b=123.123962+a;

b=b-100;

a=b;

a,2,543

1,543

2,0.0

2,123.123962

2,23.123962

1,23

字符型量

字符型量包括字符常量和字符变量。

字符常量

字符常量是用单引号括起来的一个字符。

例如'

a'

'

b'

='

+'

?

都是合法字符常量。

在Ｃ语言中，字符常量有以下特点：

1.字符常量只能用单引号括起来，不能用双引号或其它括号。

2.字符常量只能是单个字符，不能是字符串。

3.字符可以是字符集中任意字符。

但数字被定义为字符型之后就

不能参与数值运算。

如'

5'

和5是不同的。

是字符常量，不能参与运算。

转义字符

转义字符是一种特殊的字符常量。

转义字符以反斜?

quot;

\"

开头，后跟一个或几个字符。

转义字符具有特定的含义，不同于字符原有的意义，故称“转义”字符。

例如，在前面各例题printf函数的格式串中用到的“\n”就是一个转义字符，其意义是“回车换行”。

转义字符主要用来表示那些用一般字符不便于表示的控制代码。

常用的转义字符及其含义

转义字符　转义字符的意义

\n　　　　　回车换行

\t　　　　　横向跳到下一制表位置

\v　　　　　竖向跳格

\b　　　　　退格

\r　　　　　回车

\f　　　　　走纸换页

\\　　　　　反斜线符"

\'

　　　　　单引号符

\a　　　　　鸣铃

\ddd　　　　1～3位八进制数所代表的字符

\xhh　　　　1～2位十六进制数所代表的字符

广义地讲，Ｃ语言字符集中的任何一个字符均可用转义字符来表示。

表2.2中的\ddd和\xhh正是为此而提出的。

ddd和hh分别为八进制和十六进制的ASCII代码。

如\101表示字?

A"

，\102表示字母"

B"

，\134表示反斜线，\XOA表示换行等。

转义字符的使用

a=5;

b=6;

c=7;

%d\n\t%d%d\n%d%d\t\b%d\n"

a,b,c,a,b,c）;

此程序练习转义字符的使用

a、b、c为整数　5->

a,6->

b,7->

调用printf显示程序运行结果

程序在第一列输出a值5之后就是“\n”，故回车换行；

接着又是“\t”，于是跳到下一制表位置（设制表位置间隔为8），再输出b值6；

空二格再输出c值7后又是"

\n"

，因此再回车换行；

再空二格之后又输出a值5；

再空三格又输出b的值6；

再次后"

\t"

跳到下一制表位置（与上一行的6对齐），但下一转义字符“\b”又使退回一格，故紧挨着6再输出c值7。

字符变量

字符变量的取值是字符常量，即单个字符。

字符变量的类型说明符是char。

字符变量类型说明的格式和书写规则都与整型变量相同。

chara,b;

每个字符变量被分配一个字节的内存空间，因此只能存放一个字符。

字符值是以ASCII码的形式存放在变量的内存单元之中的。

如x的

十进制ASCII码是120，y的十进制ASCII码是121。

对字符变量a,b赋予'

x'

和'

y'

值：

a='

b='

实际上是在a,b两个单元内存放120和121的二进制代码：

a　01111000

　　　　b　01111001

所以也可以把它们看成是整型量。

Ｃ语言允许对整型变量赋以字符值，也允许对字符变量赋以整型值。

在输出时，允许把字符变量按整型量输出，也允许把整型量按字符量输出。

整型量为二字节量，字符量为单字节量，当整型量按字符型量处理时，只有低八位字节参与处理。

main（）{

a=120;

b=121;

%c,%c\n%d,%d\n"

a,b,a,b）;

a■b■

a<

--120

b<

---121

显示程序结果chara,b;

本程序中说明a，b为字符型，但在赋值语句中赋以整型值。

从结果看，a，b值的输出形式取决于printf函数格式串中的格式符，当格式符为"

c"

时，对应输出的变量值为字符，当格式符为"

d"

时，对应输出的变量值为整数。

a='

a=a-32;

b=b-32;

a，b被说明为字符变量并赋予字符值

把小写字母换成大写字母

以整型和字符型输出

本例中，a，b被说明为字符变量并赋予字符值，Ｃ语言允许字符变量参与数值运算，即用字符的ASCII码参与运算。

由于大小写字母的ASCII码相差32，因此运算后把小写字母换成大写字母。

然后分别以整型和字符型输出。

[Practice]//charinta=49;

charb;

chard;

b=a+10;

d=a+b;

a,2,49

b,1,随机

d,1,随机

1,49

2,随机

3,随机

2,'

3,'

l'

[Practice]//charc1,c2;

c1='

c2='

c1=c1-32;

c2=c2-32;

c1,1,随机

c2,1,随机

1,随机;

1,'

A'

B'

字符串常量

字符串常量是由一对双引号括起的字符序列。

"

CHINA"

，"

Cprogram:

，"

$12.5"

等都是合法的字符串常量。

字符串常量和字符常量是不同的量。

它们之间主要有以下区别：

1.字符常量由单引号括起来，字符串常量由双引号括起来。

2.字符常量只能是单个字符，字符串常量则可以含一个或多个字符。

3.可以把一个字符常量赋予一个字符变量，但不能把一个字符串常量赋予一个字符变量。

在Ｃ语言中没有相应的字符串变量。

这是与BASIC语言不同的。

但是可以用一个字符数组来存放一个字符串常量。

在数组一章内予以介绍。

4.字符常量占一个字节的内存空间。

字符串常量占的内存字节数等于字符串中字节数加1。

增加的一个字节中存放字符"

\0"

（ASCII码为0）。

这是字符串结束的标志。

例如，字符串"

Cprogram"

在内存中所占的字节为：

Cprogram\0。

字符常量'

和字符串常量"

a"

虽然都只有一个字符，但在内存中的情况是不同的。

在内存中占一个字节，可表示为：

"

在内存中占二个字节，可表示为：

a\0符号常量

符号常量

在Ｃ语言中，可以用一个标识符来表示一个常量，称之为符号常量。

符号常量在使用之前必须先定义，其一般形式为：

#define标识符常量

其中#define也是一条预处理命令（预处理命令都?

#"

开头），称为宏定义命令（在第九章预处理程序中将进一步介绍），其功能是把该标识符定义为其后的常量值。

一经定义，以后在程序中所有出现该标识符的地方均代之以该常量值。

习惯上符号常量的标识符用大写字母，变量标识符用小写字母，以示区别。

#definePI3.14159

floats,r;

r=5;

s=PI*r*r;

s=%f\n"

s）;

由宏定义命令定义PI为3.14159s,r定义为实数　5->

r　PI*r*r->

s

显示程序结果floats,r;

　r=5;

　s=PI*r*r;

本程序在主函数之前由宏定义命令定义PI为3.14159，在程序中即以该值代替PI。

s=PI*r*r等效于s=3.14159*r*r。

应该注意的是，符号常量不是变量，它所代表的值在整个作用域内不能再改变。

也就是说，在程序中，不能再用赋值语句对它重新赋值。

变量的初值和类型转换

变量赋初值

在程序中常常需要对变量赋初值，以便使用变量。

语言程序中可有多种方法，在定义时赋以初值的方法，这种方法称为初始化。

在变量说明中赋初值的一般形式为：

类型说明符变量1=值1，变量2=值2，……；

inta=b=c=5;

floatx=3.2,y=3f,z=0.75;

charch1='

K'

ch2='

P'

应注意，在说明中不允许连续赋值，如a=b=c=5是不合法的。

inta=3,b,c=5;

b=a+c;

a=%d,b=%d,c=%d\n"

a,b,c）;

}a<

---3,b<

--0,c<

---5

--a+c

显示程序运行结果

变量类型的转换

变量的数据类型是可以转换的。

转换的方法有两种，一种是自动转换，一种是强制转换。

自动转换

自动转换发生在不同数据类型的量混合运算时，由编译系统自动完成。

自动转换遵循以下规则：

1.若参与运算量的类型不同，则先转换成同一类型，然后进行运算。

2.转换按数据长度增加的方向进行，以保证精度不降低。

如int型和long型运算时，先把int量转成long型后再进行运算。

3.所有的浮点运算都是以双精度进行的，即使仅含float单精度量运算的表达式，也要先转换成double型，再作运算。

4.char型和short型参与运算时，必须先转换成int型。

5.在赋值运算中，赋值号两边量的数据类型不同时，赋值号右边量的类型将转换为左边量的类型。

如果右边量的数据类型长度左边长时，将丢失一部分数据，这样会降低精度，丢失的部分按四舍五入向前舍入。

图21表示了类型自动转换的规则。

floatPI=3.14159;

ints,r=5;

s=r*r*P