Microsoft Word - 第3章.doc

Transcription

1 第 3 章 数据类型 什么是数据类型? 数据类型是指 : 1 一定的数据在计算机内部的表示方式 ; 2 该数据所表示的值的集合 ; 3 在该数据上的一系列操作 在数学上, 专家们典型地用代数群论 ( 参考文献 [5]) 对它进行研究 在计算机语言中, 将数据用一定的数据类型来描述是为了将一系列相同性质的数据归类, 统一值域和规范操作, 以便这些数据在描述问题 数据抽象中得到更好的运用, 从而通过数学和计算机的手段来解决问题 对于要解决的具体问题, 一般的做法是将问题数量化, 描述成一定数据类型下的实体和相关的操作, 通过语言的编译器对其进行识别, 最后让计算机执行操作, 运行获得求解结果 以数据类型来规定数据的描述和行为的编程手段, 有利于数据的逻辑描述和正确性检查, 有利于数据操作的高质和高效 在 C++ 中, 数据类型不仅规定了某一数据是整数 浮点数或者自定义的类型名称, 而且还规定了数据的组织形式以及操作方法 数据类型是程序设计中描述数据的工具, 对数据类型的选取或规定形式, 直接决定了编程中解决问题的具体方法 C++ 中的数据类型, 有语言既定的内部数据类型 (inner types), 也有程序员自定义的外部数据类型 其中内部数据类型有 : 整数类型 (int), 字符类型 (char), 布尔类型 (bool), 单精度浮点 (float) 和双精度浮点 (double) 本章除了介绍整型和浮点型两大基本数据类型外, 还介绍系统提供的自定义类型 string 字串 这些都是初学中常用的数据类型 要学好编程, 必须理解数据类型, 学会数据说明 ; 要学习新的程序设计方法, 就要学会自定义数据类型, 而这就必须先了解语言的内部数据类型 因为自定义数据类型是以内部数据类型为基础的 3.1 整型 使用整数是人们描述自然现象的最基本的数学方式 因此, 以解决人类计算问题为目标的计算机语言首先提供了整数数据类型, 即整型 它规定了整数的内外部表示形式 表示范围以及整数的运算 ( 操作 )

2 130 C++ 程序设计教程详解 过程化编程 内部表示原理 1. 十进制数转为二进制数人们首先将十进制正整数转换成二进制整数 因为这种转换是从人类表达走向计算机理解的必要环节 转换的方法是采用 除 2 取余法, 即对被转换的十进制整数除以 2, 取其余数, 并将商再除以 2, 再取余数, 直到商为 0 每次除下来的余数按先后顺序构成了从低位到高位的二进制整数 例如 : 35= (2) 转换的具体步骤为 : 35 2= = = = = =0 1 各步骤的余数自底向上列成一个 01 串 , 即所求的二进制数 2. 二进制的计算机器 概述一个二进制数相当于一串机械开关, 一系列的机械开关构成了电子线路, 就可以用来做二进制数的逻辑运算了 由数学理论, 逻辑数学可以表达任何计算 计算机逻辑就这样随着硬件工艺水平的提高, 逐步复杂 逐步发展起来了 由于计算机内部表示数的字节单位都是定长的, 以 2 的幂次展开, 或 8 位, 或 16 位, 或 32 位, 于是, 一个二进制数用计算机表示时, 位数不足定长字节的位数时, 高位上要补足若干个 0 例如,35, 以一个字节的 8 位长和两个字节的 16 位长在计算机内部表示时, 其二进制数分别为 : 在计算机还很原始的时候, 专家们研究用怎样的二进制数表示十进制数比较有效, 既要容易转换又要便于计算 原码计算机最初有一种原码表示方法, 它是将若干字节长的位串第一位表示为符号, 其他作为二进制数的数字位 例如,8 位二进制数表示 -5, 则其第一位为 1, 其余 7 位表示成 , 凑起来就是 但是专家们发现, 原码中 0 有正 负之分, 为正 0, 为负 0, 不同

3 第 3 章数据类型 131 的计算可能得到不同的 0 值, 表达不唯一, 而且对于异号加法与同号减法要做两个数的大小比较, 它们都将使计算机内部多出一些比较电路, 导致处理的复杂性增加 反码同样, 反码是另一种二进制数表达方式, 它将正数与负数表示为相反数 因此正数有多少, 负数也有多少 相反数是指全部位取反, 即 0 变 1,1 变 0 例如, 正数 5 表示成 , 则相反数即 , 即为 -5 结果发现它同样有正 0 与负 0 两个 0, 令计算中渗入了额外的逻辑判断, 也导致复杂性的增加 两种方法从表达上说应该是明确的, 判断正负性只要看第一位就知道 但是在计算逻辑上不够简明, 故只应用在很少的场合 3. 补码 方法补码的方法是将正数与负数表示为互补数, 即两者相加去掉进位构成全 0 数 在操作上, 将正数取反加 1 即成负数, 负数取反加 1 即成正数 取反加 1 称为取补操作 取反加 1 即在反码的基础上再加 1 例如, 正数 15 表示成 的 8 位二进制数, 取补 ( 取反加 1) 而成 -15: -15=-1111 (2) = = // 取反加 1 = 的特征粗看之下, 与反码差别不大, 但是仔细一看却发现,0 的表示唯一了 : -0 = = // 取反加 1 = = // 舍去进位 = 0 统一加减法由于 0 取补后还是 0, 所以体现了二进制补码中 0 表示形式的唯一性和一致性 更重要的是, 减法可以通过加上一个负的减数来计算, 而负的减数通过取补而得到加数 减法通过减数的取补而成为加法, 加减法便统一了 加减法的统一使二进制数的操作种类减少, 最后当乘除法归并到一系列的加减法之后, 发现二进制数的计算操作就只有加法了 最高位判正负性补码同样也能通过最高位来判断数的正负性 例如 : 正数

4 132 C++ 程序设计教程详解 过程化编程 负数 补码不失其表达的直观性, 又容易转换和便于计算, 它还统一了加减法的意义, 简化了操作种类, 因此而带来了许多设计优化 因此, 整数类型采用二进制数的补码形式作为其内部表示的形式 4. 算术运算原理 加法两个十进制整数相加在计算机中是作二进制数加法运算的 例如 : 35+12= = = (2) =47 减法在二进制补码的运算中, 减法相当于取补后相加, 如果相加后在最高位有进位, 则简单地弃之了事 因此, 二进制补码运算在计算机中没有减法 例如 : 3-5= = = = (2) =-2 如果计算结果是负数, 则在取出去输出时, 取补还原成负数 乘法在二进制补码中, 有一种很有用的移位操作 8 位二进制码的左移 1 位操作就是将最高位挤出, 最低位补 0, 例如,6( ) 左移 1 位后得到 12( ), 即相当于 6 乘 2 等于 12 由于二进制整数做左移 1 位相当于乘 2 运算 所以, 二进制补码的乘法在具体的操作中都分解成了一系列的左移和加法操作 例如 : -3 5= = = 左移 2 位 左移 0 位 = = = (2) = -15 除法同理, 二进制整数做除以 2 的运算相当于右移 1 位 所以, 二进制补码的除法运算在计算机中都分解成了一系列的左 右移和加法操作 例如 :

5 第 3 章数据类型 = =( ) = =4 余 1 =4 由于整数除法中, 结果没有小数, 所以这里的除法也就是抛弃余数的整除法 读者必须明白实际实现的除法是按一定的算法来决定移位次数从而决定商, 操作过程还会做些优化 整型长度与范围 1. 有符号与无符号数 C++ 中的整型数有两种类型修饰 一种是有符号数, 用二进制补码表示 ; 另一种是无符号数, 用原始二进制码表示 有符号数有符号数就是二进制数的补码形式 通过判断其最高位, 能够知道该数表达的是正数还是负数 其所对应的类型为默认的 int, 或者 signed int 无符号数无符号数则纯粹为二进制数, 没有符号, 没有正负性, 全部表示正数 因此, 可以判定 8 位二进制无符号数的表示范围为 0 到 255 其中最大数 255 所对应的二进制数为 无符号数所对应的类型为 unsigned int 例如: unsigned int x = 23; // 正确 unsigned int z = -43; // 警告 : 无符号数非负, 招惹调试问题有符号数与无符号数都是整数类型, 当需要进行非负整数运算时, 用无符号整数, 可以获得多一倍的正数值表达能力 但是, 正数表达能力多一倍在计算机中微不足道, 用更长的整型数表示整数可能会更有效 相反, 整数的正负性表示在计算过程中却十分重要 所以, 整数多用有符号整型数, 特殊情况才用无符号整型数 C++ 默认的整型 int 即为有符号整型 有符号数与无符号数在计算机内部表示本质上是一致的, 也就是说, 操作都是相同的, 只是在值的表现 ( 输入 / 输出 ) 表示范围 合法性判断上形成了区别 补码正负数各半补码能够通过最高位判断出整数的正负性, 因此, 一定位数的二进制补码中总是有一半是正数, 一半是负数 例如,8 位二进制补码中有 128 个数最高位为 0, 即 128 个正数, 另外 128 个数为负数 正数所能表示的范围为从 0 到 127, 最大正整数是 127, 即 负数所能表示的范围是 -1 到 -128, 最小负数是 -128, 即 值得关注的是 : (1) 负数值越小 ( 绝对值越小 ), 所表现的二进制数绝对值却越大, 即 -1 为 ,

6 134 C++ 程序设计教程详解 过程化编程 而 -128 却为 (2) 所有负数, 都有正数与之对应 例如, (1) 对应 (-1), (127) 对应 (-127) (3)-128 这个数是独特的 -128 没有正数与之对应 -128 的取补后仍然是其自身 一切位数 (8 位 16 位 32 位 64 位 ) 的二进制补码都有这个特性 2. 整型长度 长度分类表整型的设计有多种长度, 有 8 位 ( 例如 char),16 位 ( 例如 short int),32 位 (int 或 long int),64 位 ( 例如 long long int) 随着计算机技术的发展, 整型数的位长也在发展 无论在什么编译器上工作,short int 能够保证定义 16 位整型,long int 能够保证定义 32 位整型,long long int 能够保证定义 64 位整型 而用 int 描述的整型, 一般表示当前编译器中默认的整型长度 例如, 在 32 位编译器中 int 代表 32 位整型, 而在 16 位编译器中则代表 16 位整型, 或许在以后的 64 位编译器中,int 将会代表 64 位整型 不管怎么说, 标准 C/C++ 保证下列整型长度的关系成立 : char 1 short int long int long long int 每一种整型长度都对应有符号 (signed) 和无符号 (unsigned) 两种 并且一般的编译器总是指定默认整型 int 为 signed 如表 3-01 所示 表 3-01 整型分类表 类型 有符号形式 无符号形式 默 认 8 位 signed char unsigned char char 16 位 signed short int unsigned short int short int 2 32 位 signed int unsigned int int 32 位 signed long int unsigned long int long int 64 位 signed long long int unsigned long long int long long int 例如 : int y = -67; // 等价于 signed int 关于 64 位整型数的表示,C/C++ 中有一种表示 64 位整型数的扩展类型 int64, 它与 long long int 所表示的整数位数是相同的, 许多编译器都实现了相同的操作 long long int 类型作为标准的时间比较晚, 在这之前都是使用 int64, 所以, 虽然它不是标准类型, 但是许多编译器考虑到历史的原因, 都兼容了它 编译器与整型长度 C++ 编译器在不同的计算机硬件上的表现是不同的 目前计算机上的主流 CPU 逐渐成为 64 位, 而目前的主流 C++ 编译器版本则仍然是 32 位的, 软件相对于硬件总是滞后 1 在一些大型机的 C++ 编译器中,char 默认为 16 位 2 32 位编译器默认 int 为 32 位

7 第 3 章数据类型 135 所谓 32 位编译器是指它能将程序源代码编译成最高为 32 位的 CPU 指令系统代码 C++ 程序的指令集受制于 C++ 的编译器 也就是说, 如果 C++ 编译器是 32 位的, 则机器哪怕是 128 位的, 其 C++ 程序的运行指令还是 32 位的 32 位编译器, 其 int 类型的长度是 32 位的 所以 : int a = ; long int b = ; // 正确, 但是在 16 位编译器上却有问题 // 正确 32 位的 int 能够表示超过 2 16 的整数, 或者说,int 与 long int 是一致的 在本书出版 的年份, 无论哪个计算机商家, 主流编译器还都是 32 位的 同理,16 位编译器生成 16 位机器指令程序, 所实现的整型是 16 位的 所以 : int a = ; // 错误 :16 位有符号整数最大只能表示为 long int b = ; // 正确 16 位的编译器将整型实现为 16 位, 所以 int 与 long int 不一致 使用低版本的编译器 时, 编程中为了整型数表示的可移植性, 应该将 int 改为 long int 32 位 C++ 编译器并非一定只能编译那些 32 位 CPU 指令系统的代码 一般来说, 为了 兼容运行环境,C++ 编译器有选择编译成各种机器系统指令的能力,32 位的编译器可以编 译比自己级别低的流行指令系统 例如,BCB 编译器可以通过编译指令的设置, 而将程序 编译成低于 32 位的机器指令 人们总是趋向使用高端机和高端操作系统, 所以从用途来看, 编译成较低长度机器指令或许只是为了能在某种低端机上运行 3. 表示范围 表 3-02 是目前流行的 32 位编译器的各种整数类型表示范围一览表 表 3-02 整型数表示范围 类 型 字节数位数 表示范围下限上限 解 释 char ~(2 7-1) signed char ~(2 7-1) unsigned char ~(2 8-1) short int ~(2 15-1) signed short int ~(2 15-1) unsigned short int ~(2 16-1) int ~(2 31-1) signed int ~(2 31-1) unsigned int ~(2 32-1) long int ~(2 31-1) signed long int ~(2 31-1) unsigned long int ~(2 32-1) long long int ~(2 64-1) signed long long int ~(2 64-1) unsigned long long int ~(2 64-1)

8 136 C++ 程序设计教程详解 过程化编程 整型数 整型数在外部表示中分两种情况 : (1) 在编程时, 表示在代码中的整数 这种整数也称为整型字面值 (literal), 它是 C++ 编译器能够接受的整数 (2) 通过输入语句读入的整数, 也就是 C++ 能够接受 ( 识别 ) 和表达的整型数 这种整数在输入时, 受到读入整型变量类型的约束 表示范围大的整型, 能够接受更长的整型数值 至于通过输出语句显示的整数, 输出时, 数值长度上将会按整数类型的表示范围, 格式上将会按输出时规定的格式控制 1. 整型字面值 十进制数在整型数表示范围 ( ~ ) 内的整数, 默认为 int 型数 例如 : int a = 23; // 整型字面值 整型数一般是指有符号整数 整型数有长度之分, 有长整型 long int 和长长整型 long long int, 分别表示 32 位和 64 位整型数 八进制数八进制整型数以 0 引导, 以 0~7 的范围表示各位数字 例如 : int b = 0235; // 八进制字面值 如果用数字 8 或 9 表示八进制数, 例如,0238, 则对编译器来说不可忍受, 将报告错误 八进制数的数值转换成十进制数值, 可以用各位数字分别乘上 8 的对应幂次来计算 例如,0235 = = = 157 八进制整数没有负数表示, 也就是说, 八进制数是无符号整数 八进制数与十进制数一样有各种长度的分别, 有长整型和长长整型的表示 十六进制数十六进制整型数以 0x 或 0X 引导, 以 0~9 和 A~F( 或者 a~f) 的范围表示各位数字 其中 a~f 分别表示 10,11,12,13,14,15 例如: unsigned int c = 0x7fa; // 十六进制字面值 十六进制数的数值转换成十进制数值, 可以用各位数字分别乘上 16 的对应幂次来计算 例如,0x7fa 等价于 = = 2042 十六进制数没有负数表示 与八进制数一样, 有各种长度的十六进制数 无符号数整型数分为有符号数与无符号数 字面值后面跟 U 或者 u 表示无符号数, 否则为有符

9 第 3 章数据类型 137 号数 例如 : long long int x = 65530U * 65530U; 整数表示成无符号数之后, 则按无符号数规则进行操作计算 ( CH3.1.5 混合计算 ) 该 x 变量定义初始化为两个无符号数 (65530<2 16 ) 的积 ( 其值介于 2 31 和 2 32 之间 ) 此处如果不用无符号整数, 则结果只能是有符号数 根据数值大小与表示范围, 其积会计算溢出, 而得到一个负数 长整型后缀 L 和 l 或者 LL 和 ll 用于区分长整型 (32bit) 和长长整型 (64bit) 在 32 位编译器下的 C++ 语言, 其长整型与整型的内部表示是相同的 有时候, 为了表示更高精度的整数, 非得用长长整型数描述不可 例如 : long long int x = LL; // 正确 long long int y = ; // 错误 : 整型数超范围 长长整型有有符号与无符号之分, 在整型数后用 U 表示无符号数 长度描述 LL 和无符号性描述 U, 次序可以任意, 也就是说 :12345ULL 等价于 12345LLU 与 12345ULL 虽然在数值上是相等的, 但是在内部表示上占有空间的大小不同, 一个为 32 位, 一个为 64 位 而且操作意义也不同, 一个是有符号操作, 一个是无符号操作 长度限制语言的描述要受到实现的限制, 即受到计算机技术发展的限制, 受到编译器的限制 例如, 文法中规定的整数字面值 ( CH5.1.2 整型数文法 ), 虽然为非 0 数字开头的递归性定义的数字序列, 但对序列的长度没有具体说明 正像标识符长度受机器限制那样, 整数字面值也受到长度的限制 例如, 下列超过整数范围描述的字面值在各个计算机中有不同的反应 : int x = LL; int a = ; 将超过 int 整型变量 x 表达范围的合法的长长整型数赋值, 将会导致 x 变量值不确定 因为在类型转换时, 可能截断高位, 保留低位, 也可能截断低位, 保留高位, 从而使数值变化不确定 存储在 a 空间的值究竟是多少呢?C++ 标准告诉我们, 当整数的表示在整型表示范围内时, 任何编译器的理解是一致的 ; 但当其超过了整型所表示的范围时, 不同的编译器有不同的处理方式, 因而, 上述 a 的值是不可预料的 一般来说, 编译器首先将其当做名字接受, 因而先进行长度检查 例如, 在 VC 编译器中, 该语句受到标识符长度限制 ( 30) 而报错 而在 BCB 编译器中编译能通过, 说明标识符长度限制没有超过, 但输出的 a 是一个莫名其妙的数 而对 20 位长度的整数字面值, 在 VC 中便能通过编译, 说明通过了长度检查, 但与 BCB 一样, 其值是荒谬的 2. 整型数的读入 读入整数的识别的程度, 受到数据类型的限定 例如,int 型变量接受 8 位之内的十进

10 138 C++ 程序设计教程详解 过程化编程 制整数,long long int 型变量接受 15 位以内的十进制整数 无符号整型变量接受无符号数, 有符号整型变量接受有符号整数 例如, 对于下列数字串 : 则对于下列流输入语句, 将正确接受 : int a; long int b; long long int c; cin>>a>>b>>c; //a 为 123,b 为 12345,c 为 但是对于 cin>>c>>b>>a; 输入操作, 则不能得到 a 的合理值, 因为流输入操作在试图接受变量 a 的输入时, 发现数字串超过整型数的表示范围 这时候,a 变量的值将不可预料, 不同的编译器将作出不同的输入处理 或许输入处理只涉及如何截断数字串, 可能影响之后的数据读入起点, 而不会因此中断程序运行 整型操作 1. 算术操作整数可以进行 +,-,*,/,% 的算术运算 进行算术操作时, 必须注意结果是否溢出 整数的算术运算的溢出其实也是有规律可循的 ( CH3.1.5 去掉进位规则 ) 其中 / 的操作是整除运算, 得到的结果为商 ( 整数 ); % 的操作是取余运算, 得到的结果为余数 ( 整数 ) 例如,9/5 得到 1, 而 9%5 得到 4 / 和 % 都涉及除法操作, 都规定除数不能为 0, 否则将导致运行错误 值得一提的是, 取余操作结果的正负性取决于被除数的正负性, 这与整除 / 操作所得结果的 负负得正 不同 例如 : 11/(-5)=-2-11/(-5)=2 11%(-5)=1-11%(-5)=-1 2. 关系与逻辑操作 逻辑值与整数值互通整数可以进行!, &&, 的逻辑操作 逻辑操作的结果值要么为 true 要么为 false, 没有其他可能 true 和 false 与 1 和 0 对应并且相容, 所以逻辑值可以看做整数值 0 和 1 将逻辑值与整数值等同看待, 这是 C/C++ 处理逻辑值的一个通融设计, 它带来了许多计算优化和精彩的代码精简 因为整个逻辑学的完备计算体系, 统统可以搬到 C++ 程序设计中来, 给编程带来多学科交叉描述 理解, 甚至找到解决问题的通同性, 从中也折射出相关的哲学意义

11 第 3 章数据类型 139 逻辑值与整数值互通, 必须将整数值也看做逻辑值 : 任何非 0 数 ( 包括正数负数 ) 等价于逻辑真, 即当一个非 0 整数作为逻辑值运算时, 其逻辑值为 1 显然, 整数值 0 便对应逻辑值 0, 这是一对一的对应 整数值 0 即逻辑值 0 关系操作整数可以做 <, <=, >, >=, == 和!= 的关系操作 关系操作的结果是逻辑值, 要么 0 要么 1, 没有其他可能 所以可以将关系操作的结果 : (1) 作为条件判断 ; (2) 作为逻辑值参加逻辑运算 ; (3) 作为整数值参加整数运算 逻辑操作逻辑运算中,! 表示 逻辑非 操作, 也就是说, 任何非 0 整数值经过! 操作, 都变成了 0, 而整数 0 经过! 操作变成了 1 && 操作是 逻辑与 操作, 操作是 逻辑或 操作, 与数理逻辑中的 非 与 或 操作对应 例如,23&&5 即 1&&1 得 1,0 1 得 1 逻辑学有真值逻辑 例如,A,B 代表某个逻辑值, 则!A&&B A&&!B A&&B 等价于 A B, 所以下列两条语句等价 : if(!a&&b A&&!B A&&B) x=12; if(a B) x=12; 从中可以看出编程中利用逻辑表达式的真值等价性, 可以进行计算的优化 3. 位操作整数可以进行 <<, >> 的移位操作和 &,, ^, ~ 的按位逻辑操作 在做移位操作时, 将整数的内部二进制数表示看做一个 01 序列串 对于左移 1 位操作, 即将最左边的 0 挤走, 而在右端添上 0 右移则反之 例如: int a = 12; //a 为 int b = a<<1; //b 为 int c = a>>3; //c 为 b 的值为 24, 二进制数左移 1 位相当于做乘 2 运算 c 的值为 1, 二进制数右移 1 位相当于做除 2 运算 因为原来右边的 3 位都被挤走, 而整数的左边补 0 移位操作在处理负数的右移时, 挤走若干位, 但却补上若干位 1 而不是 0, 这是考虑到有符号数的符号一致性 例如 : int a = -12; //a 为 int b = a<<1; //b 为 int c = a>>3; //c 为 这时候 b 的值为 -24, 而 c 的值为 -2 位逻辑操作是按位做逻辑操作 & 表示 位与 操作 ; 表示 位或 操作 ; ^

12 140 C++ 程序设计教程详解 过程化编程 表示 位异或 操作, 也就是不进位加 ; 而 ~ 表示 位反 操作 位反操作是一元操作符 例如 : int a = 12; //a 为 int b = 5; //b 为 int c = a b; //c 为 int d = a&b; //d 为 int e = a^b; //e 为 int f = ~a; //f 为 可得 c 为 13,d 为 4,e 为 9,f 为 赋值操作赋值操作除了直接赋值的 = 操作之外, 还有累积性赋值操作 例如, +=,-=,*=, /=,%= 分别表示累加 累减 累乘 累除, 累取模操作 ; 还有 ^=,&=, = 分别表示对位异或 位与 位或操作的结果进行赋值 再有 <<= 和 >>= 表示对左移和右移的结果进行赋值 累积性赋值操作的意义是清楚的 例如, a+=6; 表示 a=a+6; 因为赋值操作涉及一个变量实体的值修改, 所以左边必须是一个可以被修改的实体 ( CH5.3.4) 整数问题 1. 周而复始性 去掉进位规则讨论整数在计算机内只有 8 位的形式, 假想其类型为 int8, 并默认其为 signed, 分别创建 signed 和 unsigned 的变量如下 : int8 a1=255,a2=3; unsigned int8 b1=255, b2=3; 显然,a1 a2 的表示范围为 128~127, 而 b1 b2 的表示范围为 0~255 有符号和无符号整型的表示范围之间有一个交集 整数 255 超过了 a1 的表示范围, 如果显示 a1, 会是什么数呢? 如果 b1+b2 则又得到什么呢? 试想一下时钟的变化规律 9 点钟过了 5 个小时, 我们一般会说 2 点, 而不说 14 点 即使说 14 点, 那也是特指下午的 2 点 否则,9 点过了 50 个小时, 说成 59 点就是笑话了 9 点过了 50 个小时是几点呢? 只要 59 去掉若干个 12 就能得出结果是 11 点 因此根据走过的时数, 可以得到钟点数的计算为 : ( 起始钟点 + 走过的时数 ) 取 12 的余数二进制 8 位补码运算中,255+3 也类似钟点规律, 简单地抛弃最高位的进位 ( 取 2 8 = 256 的余数 ), 而获得结果为 2

13 第 3 章数据类型 141 因为 255 没有超过 int8 的内部表示范围, 所以其值就直接赋给了 a1, 即使一个合法整数超过了 int8 的表示范围, 也可以通过取 256 的模而获得 a1 的赋值 例如,a1=257, 其实 a1 真实的赋值是 1 因为 a1 的类型是有符号整数, 当 a1 在输出时, 就得到 -1 了 因为最高位是 1, 在输出时将会通过取补, 表现有符号类型 ; 而 b1 的类型是无符号数, 当输出 b1 时, 就得到 2 了 它也是自身类型合适的输出 混合计算由于变量 a1 a2 b1 b2 都是 8 位整型, 所以彼此之间的计算, 都在 8 位整型数中展开 无符号类型和有符号类型之间的混合计算, 不管在不在两个类型的交集中计算, 编译器都将会报告警告信息 为了安全计算, 需在两者的交叉区域中进行, 以确保不会溢出其外 例如,string 类型中描述字串长度的 length() 操作是 unsigned 整型结果 因此在写下列 for 循环控制时, 会看到一则警告 : string s="helloworld"; for(int i=0; i<s.length(); i++) // 警告 : 有符号与无符号数混合运算了 // 因为有符号数变量 i 是从 0 开始增量变化直至一个非 0 正整数, 没有取负数的可能, 有符号与无符号数混合比较运算始终在其交叉区间中进行, 所以这个循环控制的区间描述是安全的 任何其他的整型, 都有相似的规律 无符号数和有符号数在计算时都是以 2 的位数幂为模 ( 例如,int 型以 2 的 32 次幂为模 ) 来存放计算结果的 如果有相互的混合运算, 并不因为溢出而显示错误, 只在最后根据其有符号或无符号类型来表示其输出 有符号类型输出时将先判断该整数最高位是否为 1, 以决定是否输出一个负数 2. 表示范围的影响 整数局限性整数的表示范围决定了其表示的局限性 例如, 阶乘的计算 : = //X0301.cpp // 阶乘计算 = #include<iostream> using namespace std; int main(){ for(int i=1,t=1; i<18; t*=i++) cout<<i<<""<<t<<"\n"; } 得到其运行结果 :

14 142 C++ 程序设计教程详解 过程化编程 阶乘本可以按规则一直计算下去, 但是由于整型数表达范围的限制, 使得其在 13! 的时候就不正确了, 甚至表面上看,13!,14!,15!,16! 都是一个个用肉眼无法立即判断的大正数, 直到在 17! 出现负数了, 才确认计算结果溢出了 回过头一个个排查, 才发现早在 13! 的时候, 结果就已经错了 上述错误的发现毕竟是直观的, 但要等到发生好几个错误, 明显观察到情况不对之后 输出整数二进制位码我们修改一下程序, 用 64 位和 32 位整型数同时输出阶乘计算结果来观察整数中的内在规律 : = //X0302.cpp // 阶乘计算修改版 = #include<iostream> #include<iomanip> using namespace std; int main(){ long long int t=1; for(int i=1,u=1; i<18; t*=i,u*=i) { cout<<setw(2)<<i++<<" "; for(int j=63; j>=0; j--) cout<<(t>>j&1); cout<<"\n"<<setw(18)<<t<<setw(14)<<u<<" "; for(int j=31; j>=0; j--) cout<<(u>>j&1); cout<<"\n"; }

15 第 3 章数据类型 143 } 得到其运算结果 : 代码解读 代码中 t 是 64 位整型变量, 初始化为 1, 用来求正确的阶乘值以与 32 位整型数作比 较 外层循环中的 u 是 32 位整型变量, 同样初始化为 1, 用来求阶乘值, 但因为表示范围 有限, 会发生错误 t 与 u 都在循环的步长变化部分中计算下一个阶乘值, 注意 t 与 u 的表 达式之间用逗号隔开而不是分号 for 循环描述中的分号只能用两个, 且只能用来分隔循 环描述, 不允许他用 逗号可将多个表达式并成一个表达式, 这里只是对 t 和 u 求值

16 144 C++ 程序设计教程详解 过程化编程 由于将阶乘的计算 (t 和 u 的计算 ) 放到了循环步长变化部分去做了, 所以循环事实上的主体是输出处理, 而不是计算 循环角色的这种灵活多变性, 是编程语言所赋予的特征 富于创造性地应用让编程充满乐趣, 也将获得更多的代码灵巧性 内循环中的两个 for 循环分别是 64 位和 32 位按二进制输出整型数, 并通过输出格式控制进行上下个位数对齐, 以便进行观察 整型的二进制数输出中, 用到了 移位 操作和 位与 操作 这里取整型数某一位的操作, 是将该位移到个位, 再做与 1 的 位与 操作, 屏蔽其他各位, 同时得到该位 1 或 0 的值 移位操作和位与操作有优先级 ( CH5.2.5 优先级 ) 的区分 移位操作优先级高, 事实上也希望先做移位后做位与, 所以 t>>j&1 直接作了表达 但是作为流输出的 << 操作, 结合性或优先级高于后面的移位和位与操作, 所以需要将取整数某位的表达式用括号括起来 影响算法通过运行结果比较, 看到在 i 等于 13 时,64 位整数的二进制码在高 32 位上开始不为全 0 也就是说,32 位整数在计算 13! 时, 中间结果开始溢出 所得到的输出, 实际上是低 32 位二进制数值 13 后面的所有结果都一样 至于在 17! 阶乘时出现负值, 那是因为低 32 位计算中正好使 32 位最高位为 1, 而所有其他超过 32 位的进位都被切除 这就是整型数在处理中间结果溢出的内在规律 也就是说, 计算 18!, 需要用 64 位整型 如果要计算更大数的阶乘, 则需要用其他的数据表达手段 算法总是描述一般的方法, 而编程总是要考虑语言中数据描述的局限性 3. 中间结果溢出溢出的情况在整数类型的计算中如何表现呢? 例如, 在 short int(2 字节长 ) 中计算时 : short int a=234; short int b=456; short int c=6; cout<<a*b/c; // 结果 正确 但要看到, 虽然 short int 为 16 位整型, 但由于运算过程是在编译器所选定的计算机运算器即 CPU 的字长中进行的 如果编译器指定的指令系统是 32 位, 那么就会放在 32 位的整数寄存器中进行运算, 所以中间运算结果 = 不会溢出, 最后结果就能正确表示 选择编译代码的机器指令 (16 位抑或 32 位 ), 也就选择了整数运算过程在哪一个精度上进行 上述例子若生成 16 位机器代码, 则结果将不正确 : a*b/c =234*456/6 =106704/6 =1, / // 头上一位为进位 = / =-24368/6 =-4061

17 第 3 章数据类型 145 因为在 16 位的机器上运算, 将抛弃 a*b 的 16 位上的进位 即使 a b c 都是 int 型整数, 而非 short int, 结果同样错误, 因为 16 位编译器的 int 为 16 位长 只有当 a b c 是 32 位 int 型整数时, 结果才正确 下列程序的运行结果, 虽然乘除法的交换律成立, 但因其中的一个有中间结果溢出而致错 : //X0303.cpp //int 的中间结果溢出 #include<iostream> using namespace std; // int main(){ int a = ; int b = ; int c = 1000; cout<<a*b/c<<"\n"; cout<<a*(b/c)<<"\n"; }//==================================== 其运行结果为 : 整型子类 字符型 子类的概念首先是与父类具有相同的 处事原则 ( 具有相同的操作, 此外允许个别操作有自身特点 ), 其次是具有相同的基本表示 字符类型简称字符型 因为它的存储和计算模式也是二进制补码, 所有的操作与整型一样, 包括 +,-,*,/,%,<<,>>,,&,~,^,++,-- 等, 只不过字符值的表示范围比整型数小而已 字符值的取值范围取决于字符值的表示长度, 通常由编译器决定 标准 C++ 没有规定字符型的长度, 通常所见的编译器是用 8 位 (1 个字节 ) 表示字符型长度的, 也是因为在我们的学习环境中, 没有针对专业用途的大型机以及属下的 C++ 编译器, 本书所描述的字符型 ( 不加 signed 或者 unsigned 修饰 ) 由一个字节 (8bit) 构成 字符值根据有符号数与无符号数不同而取范围 -128~127 和 0~255 字符值除了表示以规定范围的整型数外, 还

18 146 C++ 程序设计教程详解 过程化编程 可以表示成专门的字符字面值 字符在输入 / 输出时的表现, 与整型数不同, 这是字符型的操作区别于整型的地方 字符还是字串的元素, 字符型是字串处理的基础 1. 字面值 字符字面值简称字符, 而字符值是字符所对应的整数值 字符型的每个字符不管有形无形 ( 可见与不可见 ) 都对应一个整数, 以此方式与整数操作保持兼容和互通 C++ 的语言文字即语言规则所允许的文字, 需要用编译器进行理解或检查, 其取自 ASCII 码表的可见字符集的一个子集 C++ 语言随着发展或许会允许编译器识别更多的字符甚至多国文字 程序运行中当做数据的输入 输出 处理的字符, 即字符型所用的字符集, 远比 C++ 语言文字所用字符集要广 当有特殊字符处理需要时, 还可以使用宽字符型 这里所述的字符型所用的字符集, 为常用的 ASCII 码表所列字符 ASCII 码字符构成字面值, 它直接用单引号括起来以表示字符 例如,'a','x','?', '$' 等字符 ASCII 码有 128 个字符, 其中 ASCII 码值从 0 到 31 和码值 127 为不可见字符 不可见字符也称控制字符 ASCII 码表的可见字符可以通过下列程序打印出来 : //X0304.cpp // 输出 ASCII 码可见字符 #include<iostream> #include<iomanip> using namespace std; // int main(){ for(char c=32; c<=126; c++) cout<<setw(5)<<int(c)<<" "<<c<<((c%8)==7? "\n":""); }//==================================== 其运行结果为 : 32 33! 34 " 35 # 36 $ 37 % 38 & 39 ' 40 ( 41 ) 42 * , / : 59 ; 60 < 61 = 62 > 63? 65 A 66 B 67 C 68 D 69 E 70 F 71 G 72 H 73 I 74 J 75 K 76 L 77 M 78 N 79 O 80 P 81 Q 82 R 83 S 84 T 85 U 86 V 87 W 88 X 89 Y 90 Z 91 [ 92 \ 93 ] 94 ^ 95 _ 96 ` 97 a 98 b 99 c 100 d 101 e 102 f 103 g 104 h 105 i 106 j 107 k 108 l 109 m 110 n 111 o 112 p 113 q 114 r 115 s 116 t 117 u 118 v 119 w 120 x 121 y 122 z 123 { } 126 ~

19 第 3 章数据类型 147 for 语句通过字符变量 c 从 32 到 126 的循环, 这正好是全部 ASCII 码的可见字符 ( 包括空格字符 ) 程序每次输出一个 ASCII 码 ( 整数 ) 和其对应的字符, 并控制每行输出 8 个 ASCII 码和所对应的字符 例如, 大写字母字符 'A' 表示整数 65, 而小写字母字符 'a' 却表示整数 97 而且看到空格也是一个字符, 其对应的 ASCII 码为 32 一开始可能不习惯的是, 数字字符 '3' 的 ASCII 码是 51, 所以若用数字字符值与整数进行运算, 例如,'5'*2 得到的是 106 而不是 10 这也正好说明数字与字符值的不同性 2. 转义符 概念编程是输入一些符合语言文法的文字字符, 那都是些可见的 ASCII 字符 编程应该能够接受一些不可见的 ASCII 码控制字符, 以便满足按指定格式输出的需要 换行符 \n 作为不可见字符, 前面的章节已经在用 除了那些可见 ASCII 字符之外,C++ 还允许使用一种特殊形式的字面值, 用以表达不可见的 ASCII 字符 这种特殊形式的字面值以 \ ( 称为转义符 ) 开头, 后跟一个格式字符, 称为转义字符 (escape character) 例如, 换行符就是一个转义字符, 其格式字符为 n 转义字符表使用转义字符的目的是在编程中描述不可见字符 并不是每个控制字符都有其格式字符, 是有些常用的控制字符才有其转义形式 但是可以通过 ASCII 码, 描述所有的控制字符, 方式就是在转义符后跟十六进制 ASCII 码 表 3-03 描述了常用的转义字符与 ASCII 码十六进制数的对应, 并描述了该字符所控制的动作 表 3-03 C++ 转义字符 字符形式 整数值 代表符号 \a 0x07 响铃 bell \b 0x08 退格 backspace \t 0x09 水平制表符 HT \n 0x0A 换行 return \v 0x0B 垂直制表符 VT \r 0x0D 回车 \" 0x22 双引号 \' 0x27 单引号 \? 0x3F 问号 \\ 0x5C 反斜杠字符 \ \ddd 0ddd 1~3 位八进制数 \xhh 0xhh 1~2 位十六进制数 解释有时候需要单独输出转义符 \ 自身 由于字符 \ 已被用作为转义符, 所以 \ 后面跟上一个字符可能会被看成是一个控制字符的转义字符 为了解决在代码中单独表示字符 \ 的问题, 用双写字符 ( 即 \\ ) 的形式来表示单独的 \ 字符 例如,"or\\and" 与 "or\and" 完全是两个意思, 前者表示字串 or\and, 后者表示字串 or+ 响铃 +nd

20 148 C++ 程序设计教程详解 过程化编程 字串用双引号括起来, 字符用单引号括起来, 这是 C/C++ 语言的规则 可是, 为了描述字串中所含有的双引号, 或者单独描述一个单引号字符, 我们就陷入了困境 例如, 字串中含有双引号,"I say, "good"" 就不能正常理解 为了解决这个问题, 在描述双引号和单引号字符时, 用转义符来描述, 即 \" 和 \', 而在作为字串的边界或字符的边界时, 则无须转义, 直接表示 转义字符的双字符特征, 决定了一对单引号除了括起一个字符, 表示一个字符字面值外, 还可以括起含两个字符的转义字符, 来表示独立的字符字面值 例如, \n 只是一个字符字面值 在转义字符表中没有出现的控制字符, 也有可能会需要描述, 这时候就会用到转义符后跟 ASCII 码 ( 整数 ) 的形式 例如, 要描述 ASCII 码为 6 的控制字符, 可以写成 \06 ASCII 码的可见字符也可以用转义字符的形式表示 例如,'A' 的 ASCII 码为 65,65 的八进制数为 101, 十六进制数为 41, 所以可用两种数制来表示字符 'A' 的转义形式 : \0101 或 \x41 3. 输入 / 输出 输入若用字符变量去读一个字符, 那么这个变量值就是该字符所对应的 ASCII 码值 因此, 如果用字符变量去读一个数字字符, 那么这个变量值就是该数字字符的 ASCII 码值 ; 如果用整型变量去读一个数字字符, 那么, 这个变量值就是这个数字值 例如 : char a; cin>>a; // 输入 6 得到字符 '6' 即 54 int x; cin>>x; // 输入 6 得到整数 6 cout<<a*2<<"\n"; // 输出 108 cout<<x*8<<"\n"; // 输出 48 数字字符与数字值 ( 整数值 ), 在字符或字串处理中经常需要转换 例如, 一个 string 字串变量赋有一个数字串 "123", 希望通过下标访问每个字符, 转换为整数 123 则有: string a="123"; int x = (a[0]- '0') *100+(a[1]- '0') *10+a[2]- '0'; //x 得到 123 a[0] 字符为 '1','1'-'0' 便得到 1, 同样,'2'-'0' 得到 2,'3'-'0' 得到 3, 因此通过上述表达式计算, 就可以将字串 "123" 转换成整数 123 了 输出按字符型的长度为 1 字节算, 它只能表示 256 个状态值 由于 ASCII 码有 128 个字符, 所以可以用所有正数表示所有 ASCII 码值, 而负数便可用来表示各种非正常状态 当然在进行存储和计算的时候, 字符值可以是所有正负状态之一 例如 : int c = '\a'; char b = 5; char a = 10;

21 第 3 章数据类型 149 a -= c; b -= c; 则 c 应该为 7( 从转义字符表得 ); 计算结果,a 应该得到值 3, 这个值对应的 ASCII 码是一个不可见字符 ;b 应该得到值 -2, 这个值不在 ASCII 码所能表示的范围内 a 和 b 这种取值, 如果以字符打印, 因为没有对应 ASCII 字符, 因而达不到输出效果 当然, 有时候显示的是一个中文字, 如果系统中安装了汉字系统的话 整数作为抽象的数字形式表现, 无所谓取值的对与错 而字符如果要进行输出表现, 其值只能为正数, 以代表特定的 ASCII 码 而且若是不可见字符的话, 还必须保证有控制意义 因为字符型的输出并不是输出整数, 而是该字符值所代表的 ASCII 码字符 例如 : int a = 67; char b = 67; cout<<a<<""<<b<<"\n"; // 值虽都为 67, 但其结果一为整数 67, 一为字符 C 这就是 CH2.3.1 中的问题 字符三角形 的解答中, 为什么输入一个字符给字符变量, 而输出时显现的是字符而不是整数的原因了 cout 流能区别类型 如果是整型, 则输出的是整数, 如果是字符型, 则输出的是 ASCII 码 ( 整数 ) 所对应的字符 4. 可移植性 值得注意的是, 有些地方和机器环境用的不是 ASCII 码 (ASCII 码并不是语言文字所使用字符集的终极标准 ), 结果, 字符型的整数值可能对应另一种码表 因此, 为了代码可移植, 不要用整数对字符变量进行赋值, 应以字符字面量对字符变量进行赋值 例如, 下面代码输出一个腰长为 10, 每行依字母序展开的三角形 : //X0305.cpp // 字母三角形 #include<iostream> using namespace std; // int main(){ for(int i=1; i<=10; ++i) { cout<<string(10-i, ' '); for(char ch='a'; ch<'a'+2*i-1; ++ch) // 输出 ABC 共 2i-1 个字符 cout<<ch; cout<<'\n'; } }//==================================== 其运行结果为 :

22 150 C++ 程序设计教程详解 过程化编程 A ABC ABCDE ABCDEFG ABCDEFGHI ABCDEFGHIJK ABCDEFGHIJKLM ABCDEFGHIJKLMNO ABCDEFGHIJKLMNOPQ ABCDEFGHIJKLMNOPQRS 代码中的内循环, 完成输出 2i-1 个字母字符的工作, 其循环变量 ch 是字符型的 ch 的取值为从 'A' 到 'A'+2*i-1 如果将'A' 写成 65, 也可以工作, 但是, 并不一定在任何计算机环境上运行都能得到同样的结果 原因是字符 'A' 的整数码 65 并不构成计算机字符表示的标准 所以循环如果写成下列这样, 其可移植性就差 : for(char ch=65; ch<64+2*i; ++ch) // 输出 ABC 共 2i-1 个字符 cout<<ch; 枚举型 1. 枚举型枚举是对整数区间取若干个整数值从而框定整数子集的一种自定义机制 所匡定的整数子集称为枚举类型, 简称枚举型 定义枚举型时以关键字 enum 引导, 枚举型的名称可以自定义, 程序员还可以对框定的整数子集中的整数值取名 例如, 下列是一个枚举型定义 : enum Week{ Mon, Tue, Wed, Thu, Fri, Sat, Sun }; enum 为关键字, 引导枚举的类型定义 其枚举型的名称为 Week 一对花括号中各个值即是从整型数中枚举出来的若干个值 这便定义了一个整型数的子集类型, 类名称为 Week, 其全部值为 Mon,Tue,Wed,Thu,Fri,Sat,Sun 分别表示整数 0,1,2,3,4, 5,6 2. 枚举符 概念枚举的值必须用名字表示, 所取的名字要防止与其他变量名或类型名冲突 枚举值所用的名字即为枚举符 在定义枚举型时, 需要用花括号具体描述整型数的子集 描述的方式, 便是用枚举符来表示枚举值 枚举符是自定义的名字 在一个枚举类型定义中, 一个枚举符只能代表一个整数值 一个整数也最多只能由一个枚举符表示 枚举符与整数是一一对应的关系 枚举值上面定义的 Week 枚举型, 定义了 Mon,Tue,Wed,Thu,Fri,Sat,Sun 这么几个枚

23 第 3 章数据类型 151 举符 因为没有指定整数, 所以就默认为 : 第一个枚举符对应整数 0, 第二个枚举符对应 1, 以此类推 因此, 在 Week 中,Mon=0,Tue=1 Sun=6, 一共由 7 个整数值构成了一个整数子集, 并且这个整数子集中的每个元素都有相应的枚举符 名字 ( 枚举符 ) 与整数的对应可以不默认, 也就是人为规定 例如 : enum Color{ Red=5, Green, Yellow, Blue=20, Orange }; 则在 Color 枚举型中, 名字 Red 被指定对应整数 5,Green 则顺延对应整数 6,Yellow 对应 7 之后的 Blue 又人为指定为整数 20, 则 Orange 便顺延对应整数 21 也就是说, 没有指定整数值的枚举符, 按上一项的值, 依次默认下推 所以 Red 指定整数 5 之后,Green 没有指定值, 便默认为 6 3. 枚举实体 枚举变量有了枚举型, 便可以定义枚举变量 枚举变量一般都取该枚举型整数子集内的枚举符 枚举变量与整型数的操作兼容 例如 : Week day=sun; Color color=green + 1; //Yellow 一般对于超过枚举范围的赋值行为就是不确定的了 定义枚举时的最大取值不能超过整型的最大值 枚举操作值得注意的是, 枚举型虽然是类型, 但在枚举型定义中已经规定了若干个代表整数值的枚举符 枚举符可以直接代表对应的整数值参加整数计算 因而枚举变量的定义并不是必须的 例如 : enum Week{ Mon, Tue, Wed, Thu, Fri, Sat, Sun }; int a; cin>>a; if(a==mon) cout<<"mon\n"; 4. 枚举设计意图 定义枚举型枚举型定义的并不是一个具有闭运算的自成体系的像整型这样的子代数 编程中已经有了整数类型, 便不需要这样的子代数了 枚举型定义的是若干个与整型数对应的枚举符 通过名字指认的整数值, 能够剥离整数的抽象性质 例如, d = Mon; 与 d = Green; 与 d =1; 这三者通过枚举符的使用与否, 能够区分变量 d 操作的意义, 即从中可以知道 d++ 是在日期上消逝一天, 还是在颜色上加浓一些, 还是仅仅做数量上的抽象变化 看重枚举符枚举符一旦定义则在程序运行的全程中不能改变, 所以它常常代替整型常量使用, 这才是设计枚举的真实目的 也就是说, 寥寥几个枚举符, 代表几个经常使用的整数, 可以脱离枚举型变量定义而与其他整数进行比较和运算

24 152 C++ 程序设计教程详解 过程化编程 有时候枚举符甚至比整型常量还管用 因为常量通常需要初始化的形式, 需要实体空间 所以, 模块之间切换 ( 例如, 函数调用 ) 时, 其值也就需要传递 而枚举符是在编程中确定与整数的对应, 在编译中 ( 而不是在运行中 ) 确认, 并在运行之前枚举符已经转换为整数, 因此在运行中, 枚举符代表的整数无须去对应一个可存放的内存实体 布尔型 1. 概念 整数 1 和 0 两个值构成了 bool 型的表示范围 相当于自定义了枚举型 : enum bool{ false, true }; 注意,true 和 false 都是关键字, 可以认为是 C++ 语言定义的枚举符 因而程序员如果再定义这两个名字, 就会与关键字发生冲突 bool 型是只有两个整数的类型, 其范围窄了一些, 但是用它表示逻辑 true 和 false, 却可以表达千千万万的真假命题和逻辑表达式的值 C++ 表达式值的大小比较, 条件的真假判断, 还有一切逻辑推理 ( 运算 ) 的结论都用 bool 型值来表示 2. 布尔值操作 整数与布尔值对应用任何非 0 整数给 bool 型变量赋值时, 其值都为 1, 甚至非整数的其他类型, 只要非 0, 其值也是 1 因此: bool a = 3; //a 为 true( 与 1 对应 ) bool c = a+a; //c 为 true ( 1+1=2,2 表示为逻辑值即为 1) bool d = a-c; //d 为 false ( 值为 1 的 a - 值为 1 的 b, 得 0) 布尔值的逻辑操作 bool 型变量值的 && 操作 操作! 操作所得的结果, 也是逻辑值 例如对于上面的 bool 型变量定义 : c = a && d; d =!a; if( a d ) cout<<"ok\n"; 布尔值的输出 bool 型的输出形式可以选择, 默认为整数 1 和 0, 如果要输出 true 和 false, 则可用输出控制符 : cout<<boolalpha<<d<<"\n"; // 输出结果为 false 3. 布尔型的意义 逻辑的专门表达性编程无时无刻不在与真假条件或 0 1 状态打交道 我们经常会设计一个函数或者一

25 第 3 章数据类型 153 个表达式, 通过计算来获得真假的结论, 以便决定后续工作进行的方式 因此, 布尔型值的描述带给我们一种专门区别于数据处理和数值计算的数据类型 成就布尔代数思想布尔型虽然其中只有两个值 true 和 false, 但它其实蕴含了二进制数的计算思想, 也是一个布尔代数体系的缩影 从布尔代数体系知道, 理论上, 布尔代数通过自己的封闭运算系统, 可以表达一切数学模型 演算和定义一切数学问题 所以, 布尔类型不但带给我们一种表达真假判断的特定性, 还带给我们一套逻辑计算系统 只要能够建立起一套构造计算的方法, 就能够用来辅助解决单纯靠数值计算遇到的复杂问题 布尔代数体系与计算机内部的构造密切相关, 与计算表达密切相关 其机械开关的二态性和逻辑可运算性, 使得计算机可以被看做是一台布尔代数的演算机器, 能够进行充分复杂的计算 整数的布尔化在 C/C++ 中, 布尔值与整型值是相容的 也就是说,true 和 false 可以等价于整数 1 和 0 更进一步, 整数可以作为逻辑值参加运算 例如, a=3&&5; 则 a 的赋值为 1 整数与逻辑值的通同性, 使得整数与逻辑值融为一体, 逻辑值成为整数的子集, 编程中自然成全了许多谓词演算 ( 即返回布尔值的函数 ) 的设计, 而许多逻辑计算又可以演变成为二进制整数的数据处理, 从而又导致许多代码的优化 3.3 浮点型 浮点型数 1. 编程中的描述 浮点型数概述浮点型数就是浮点字面值, 简称浮点数 浮点数在表示的时候, 有直接表示和科学表示两种形式 浮点数按表示能力, 或按长度又分 float,double,long double 三种 浮点数在表示绝对值大小方面的能力比整数强很多, 所以很多宏观和微观数据的计算处理需要浮点数 但是浮点数因为大小表示能力强了, 其精度表示就比同等长度的整型数差一些了, 而且一般认为, 浮点数的运算性能比整型数差一些 除此之外, 浮点数还有近似表达的问题, 所以编程精确输出浮点数问题 判断浮点数之间的相等问题要复杂一些 ; 计算机浮点数内部表达原理比整型数也要复杂一些 ; 计算过程中, 计算机要判断处理溢出和无穷大问题, 而且运行错误的情况分类也要比整型数复杂一些 浮点数的表示分输入识别的浮点数 输出表达的浮点数以及编程中表达的浮点数

26 154 C++ 程序设计教程详解 过程化编程 三类 直接表示编程中对浮点数的直接表示就是描述一个有限长度的十进制小数 因为直接表示的小数一定带有小数点, 所以区别于整数 小数点前若无有效数, 可以省略数字 但是小数点后若无有效数, 则不能省略数字 0, 否则就成了非法表示 如果连小数点也省略, 就成了整型数 用整型数赋值给浮点型变量, 就会导致编译器的类型转换工作 例如 : double a =.92; double c = 9.; // 错误 : 应为 9.0, 不能省略 0 double b = 9; // 正确 : 编译器将把整型数 9 转换成浮点数这些规则细节适合于三种不同的浮点型 科学表示法用科学记数法表示浮点数需要在小数描述的基础上增加阶码描述 小数与阶码中间必须要有字母 E 或 e 将两数隔开 ; 小数可以是整数, 也可以是直接表示的小数 ; 小数作为数值表示的主体, 不能省略 ; 阶码是整数, 可以有前导 0, 可以有正负号, 但不能是小数 例如 : double a = E15 double b = 1e0.5 double c =.e05 double d =.2e // 错误 : 不允许省略尾数部分, 简直是变量名了 // 错误 : 阶码应为整数 // 错误 : 尾数应为合法小数, 不能仅以." 表示 // 正确 浮点数后缀浮点字面值是有类型区别的, 它们由后缀决定 : (1) 后缀为 F 或 f: 表示单精度 (float); (2) 后缀默认 ( 无后缀 ): 表示双精度 (double); (3) 后缀为 L 或 l: 表示长双精度 (long double) 例如 : float f1 = 19.2f; double d1 = 19.2; long double ld1 = 19.2L; //float 型字面值 //double 型字面值 //long double 型字面值 用大写和小写字母作为后缀效果是一样的 显然, 如果将高精度的数赋给低精度类型的变量, 将引起精度丢失 ; 反之, 如果将低精度的数赋给高精度类型的变量, 则高精度变量也只有低精度的数值 ( CH3.3.5 精度丢失 ) 要注意这两个浮点数的表示 :12345F L 虽然是整型数, 但是后面加了 F 标记, 所以表示为 float 型数 一个数尾部加了 L 标记, 在整型数中表示长整型, 在浮点型数中表示长浮点型, 所以

27 第 3 章数据类型 155 L 标记之前的数为整型或浮点型, 就决定了该数为长整型或长浮点型数 为了表示长浮点型数, 后缀之前的数必须为小数, 以示与整型数的区别 对于用科学表示法表示的浮点字面值, 其后缀 F 或 L 表示与用浮点数直接表示的意义相同 精确性的类型制约小数的直接描述的准确性受到类型的制约 例如 : //X0306.cpp //test float format #include<iostream> #include<iomanip> using namespace std; // void print(float f){ cout<<f<<"\n"; }// void print(double f){ cout<<f<<"\n"; }// int main(){ cout<<fixed<<setprecision(8); print( ); print( f); }= 得到的输出结果为 : 前者是将浮点数以 double 类型输出, 后者是以 float 类型输出, 它们都设定为固定小数输出形式, 小数精度设置为 8 位 从中可以看出两者在表示能力上的差异 2. 输入描述 精度与类型的关系浮点数在输入时不接受 ( 识别 ) 尾部后面的 F 或 L 标记, 完全依赖于浮点类型 精度高的浮点型接受 ( 识别 ) 位数多的浮点数 例如对于下列输入内容 :

28 156 C++ 程序设计教程详解 过程化编程 E E-58 识别读入浮点数的程序 : //X0307.cpp //test float format2 #include<iostream> #include<iomanip> using namespace std; // void print(float f){ cout<<f<<"\n"; }// void print(double f){ cout<<f<<"\n"; }// int main(){ cout<<fixed<<setprecision(8); float f; double d; cin>>f>>d; print(f);print(d); cin>>f>>d; print(f);print(d); cout<<scientific; cin>>f>>d; print(f);print(d); }= 得到下面的结果 : e e-54 代码解读程序先是设置了定点输出格式, 观察 float 与 double 型数显示的效果 结果, 对于输入的 7 位十进制数得到了同样的数值, 但是对于有效位数达 15 位的两个数,float 型输出的表现明显不如 double 了 特别是在识别科学表示法的两个数中, 因为精度跟不上,float

29 第 3 章数据类型 157 型表示只能显示 0, 而 double 型表示就可以输出准确的输入值 3. 输出描述 输出按格式控制的规则输出浮点数与在代码中描述浮点数不同 代码中描述的浮点数 ( 浮点字面值 ) 通过编译成为内部浮点数 它需要语言的浮点数规范, 以让编译器能理解, 准确无误地转换成内部浮点数 但输出浮点数是将内部浮点数按输出格式 ( 宽度 空位及填充字符 ) 有效位数 小数精度等规定进行显示 输出浮点数时, 若浮点数值有效位偏离小数点较远, 将自动按科学表示法输出 按固定格式输出时, 浮点数的有效位不论偏离小数点多远, 总是会将整个小数按格式全部输出示人 按科学表示法输出时, 没有后缀表示 ( 加 F 表示 float 等 ), 尾数部分也没有省略形式, 阶码总是标记有正负号, 阶码位数按精度不同而取 2 到 4 位不等 而且, 小数部分总是按十进制数的规格化输出, 即小数点前只保留一位, 且该位非 0 小数点的真实位置通过阶码表示 注意 : 十进制数的规格化在输出时与输入识别时不同 输入时, 要求统一为只有小数点 尾数和阶码, 没有整数部分, 因而可以省略小数点前的那位数 当然规格化数的尾数第一位应为非 0 数字 字面值与输出对照描述一个浮点字面值, 将其输出, 虽也为科学表示法, 但其格式或许大相径庭 例如 : float f = E025; double d = e0023; cout<<f<<"\n"<<d<<"\n"; cout<< e0014<<"\n"; cout<<scientific<<setprecision(10)<<f<<"\n"<<d<<"\n"; cout<< e0014<<"\n"; 得到的输出形式为 : e e e e e e+22 前面三行结果表示一个有效位偏离小数点很远而自动以科学表示法输出 精度不同的变量, 直接字面值都不影响输出结果 后面三行结果是指定用一定精度的科学表示法输出 从中看出,float 型精度表示不够, 勉强凑足输出位数, 但与 double 型数已经有所区别

30 158 C++ 程序设计教程详解 过程化编程 十进制小数 1. 实数与计算机 用计算机表示小数十进制小数表现了数学中的实数数系, 人们研究高等数学离不开它, 科学计算也离不开它 为了让计算机有更强的数值表现能力, 十进制小数必须表示成计算机表示形式不可 十进制小数要表示成计算机认可的形式, 最主要的影响因素是宏观数字和微观数字的表达, 因为它们偏离实数数系中的 0 实在太远了 如果硬来, 那计算机不知道要用多少位二进制数才能表示一个真实的小数呢 定点数表示的失败计算机中所表示的数都是 01 序列, 或者说是由二进制的位拼凑而成 要在一个固定长度的 01 序列中表示一个小数, 专家们尝试用定点数的方法 定点数是确定某一个小数位置, 也就是说, 固定整数部分和小数部分的长度 例如, 32 位定点数用 1 位表示符号,16 位表示整数,15 位表示小数 : 符号整数小数 X XXXXXXXXXXXXXXXX XXXXXXXXXXXXXXX 结果发现它的表示范围仅仅只有 2 16, 即几万, 小数精度也只有大约 5 位十进位数 定点数若论精度, 甚至还不能描述 7 位小数 ( ) 的 π 值 ; 论大小, 连地球半径 ( 按米算, 有 米 ) 都无法表示 定点数的表示离科学计算的目标太远, 因而早早地被放弃了 浮点数浮点数的方法, 就是专门腾出一部分固定长度的位数用来表示小数点的偏移 ( 阶码 ), 余下的另一部分用来表示小数部分 ( 尾数 ) 这种表示方式就是实现了用计算机来表示的科学记数法 尾数的长度决定精度的大小, 阶码的长度决定一个数的数量级 专家们发现通过科学确定尾数与阶码的长度, 可以既保证一定范围的精度, 又能够对应某个数量级的空间描述 这种方法所表示的数, 当参加计算发生值的改变后, 可以很容易地调整其小数点和阶码, 使其规格化而有利于进一步的计算 这种具有小数点 浮动 ( 左右偏移 ) 的特点, 称其为浮点数 或者说, 浮点数是科学记数法在计算机中的实现 2. 十进制小数的自身表示 科学表示法原理十进制小数通常可以用科学记数法表示 例如, 可以写成 : 其中, - 是符号, 幂次 ( 指数 )3 称为阶或阶码,3065 是小数点之后的部分, 也称为小数部分, 更正式一点, 称为尾数 其左右端非 0 数字的最长的数字序列称为有效值 (significance) 无论是 还是 , 其有效值都是 3065 对于后者,3065 恰好也是尾数 (mantissa)

31 第 3 章数据类型 159 相对实数来说, 小数表示实数的区域实在有限, 写上十几位数已经很了不起了, 但是用科学记数法, 用指数的形式, 哪怕表示一个天文数字也可以八九不离十 用科学记数法的最大优点是可以表示一个大数, 其有效位值偏离小数点左边很远, 或者可以表示一个小数, 其有效位值偏离小数点右边很远 指数表示数幂的形式这么好, 因此被大量地用作科学计算 相应的表示形式也被称为科学记数法了 用科学记数法来表示一个小数, 其表示方式并不是唯一的, 因为它也可表示成 以及 等等, 其小数点可以左右偏移 但不管小数点怎么移动, 这个数的有效值还是不变, 都是 3065 只不过其尾数会随着小数点的移动而变化, 或为 065, 或为 用科学记数法表示的小数进行计算是很方便的 利用其小数点的左右偏移 ( 浮动 ), 使两数的阶码对齐, 对尾数做加减法, 就是两个小数的加减操作了 例如 : = // 向后一项对齐 = 或者也可以向前者对齐 : = // 向前一项对齐 = 科学记数法的小数做乘除法, 甚至不需要对齐阶码 做乘法时, 小数相乘, 阶码相加 ; 做除法时, 小数相除, 阶码相减 对计算结果再按需要做一下阶码调整就可以了 例如 : ( ) = // 小数相除, 阶码相减 = // 阶码调整 规格化为了让十进制数表示法唯一, 也是让尾数与有效值统一, 更希望用有限的位数表示尽可能多的有效位数, 有必要将十进制小数规格化 (normalization) 十进制数的规格化是将科学表示法的小数通过阶码调整, 写成小数点后第一位为第一位有效数字的方式, 即小数点前只有唯一一个数字 0, 小数点后第一位即排列有效数的表示方式 例如, 规格化后为 因为规格化要求小数点后的第一个数字非 0, 这就使 不能写成 或者 规格化保证了尾数与有效位数的统一, 也就保证了浮点数表示的唯一性 小数规格化之后, 便使其有效位最大化, 从而可最大程度地表达小数的精度, 有利于在运算中尽量保留计算的精度 转成二进制小数在计算机内部, 小数是以二进制位序列表示的 为了让计算机表示十进制小数, 要先将其转换为二进制小数 转换的方式是将十进制数分为整数部分和小数部分分别转换 整数部分的转换, 采用 除 2 取余法 小数部分的转换, 一种典型的做法是采用 乘

32 160 C++ 程序设计教程详解 过程化编程 2 取整法 即对被转换的十进制小数乘以 2, 取其整数部分 (0 或 1) 作为转换成的二进制 小数部分的第一位 ; 再取其余下的十进制数小数部分, 再乘以 2, 又取其整数部分作为二 进制小数部分第二位 ; 然后再取余下的小数部分, 再乘以 2, 直到余下的小数部分为 0 或 者已经取到了二进制小数足够的位数 每次取的整数部分 ( 或为 0 或为 1) 按先后次序, 构成了二进制小数部分从高位到低位的数字排列 例如, 十进制小数 , 转换成二进 制小数的具体步骤为 : 十进制小数乘 2 取整部分 余下的小数部分 二进制小数部分 = = = = 最后得 : = (2) 有时候在转换中, 二进制小数的某些位会周而复始地重复, 以致无穷 例如, 将 0.6 转换成二进制小数, 转换的具体步骤为 : = = = = 下一步是 0.6 2, 又回到了开始转换的第一行 这说明 0.6= (2), 十 进制数 0.6 是个有无穷循环小数位的二进制小数 在数学上将尾数中重复部分的数字序列两端各用一个着重号标记 例如, 将转换后的 二进制小数表示成 : 0.6 = (2) = (2) 计算机的表示是有限的 在计算机内, 要表示上述无限循环的二进制数, 只能截取到某一位, 至多再考虑一下 0 舍 1 入, 也就是说, 只能表示到某个精度 所以一个确定值的十进制小数转换成二进制小数, 可能无法精确表示, 而只能得到一个近似数 位浮点数 1. 浮点数表示 浮点数标准浮点数的构造, 是把整数部分和小数部分都看成是数字部分, 称为有效数字或尾数, 然后再用一个阶码 ( 幂次 ) 来表示数值的规模 完整的浮点数由符号位 阶码位和尾数位这三个部分组成 32 位浮点数是计算机中比较小型而又比较典型的小数构造 搞清 32 位浮点数的构造

33 第 3 章数据类型 161 就能了解浮点数表示的概貌 浮点数的表示原则, 是希望用确定长的位数表示尽可能多的有效位数 ( 精度 ) 和尽可能大的数域范围 ( 幂次 ) 32 位浮点数构造, 按国际标准浮点数表示 ( 即 IEEE 国际标准 754), 是由 1 位符号位,8 位阶码位和 23 位尾数位组成的 符号位用 1 位, 以 0 1 两个状态表示一个数的正负性 它与整数补码表示中的高位符号判定是一致的, 所以用第一位而不是用其他位来表示浮点数的正负性 规格化十进制小数转换成二进制小数时, 其表示方式是不统一的 为了使二进制小数的表示唯一, 就要像十进制数规格化那样对二进制小数进行规格化 这是最终能够表示成计算机浮点数的必然途径 二进制小数的规格化是通过调整浮点数的阶码使得该数的有效值在 1 与 2 之间, 即二进制浮点数的整数部分为 1 例如, 手工转换 为二进制规格化数 : = (2) = 要注意的是,32 位二进制规格化数, 不像十进制数规格化那样要求小数点后第一位必须为非 0, 而是要求小数点前面的一位必须为 1 多出一位精度如果二进制浮点数像十进制浮点数那样规格化, 即要求小数点后第一位非 0, 那么, 其小数点后第一位的非 0 值只能为 1, 它构成了浮点数尾数的一部分, 在计算机内部占去了表示精度的宝贵 1 位, 并使得规格化之后的小数第一位永远为 1 实际上, 永远为 1 的那一位是没有必要的 因而规格化二进制数时, 只是采用了十进制数规格化的原理, 也就是固定 1 位非 0 数字的位置, 其值由阶码去调整 但是根据二进制数的每位数字只有 0 和 1 的特点, 固定的那 1 位一定是 1, 就可以采用全部尾数挪前 1 位的办法将这 1 位省出来 ( 将最高位从尾数中挤到小数点前面去 ) 因此, 二进制小数在规格化后的尾数值加上整数部分总是小于 2 而又不小于 1 0 舍 1 入不同精度的浮点数在尾数表达上都有一个舍入问题 就十进制来说, 是四舍五入 ; 就二进制浮点数来说, 是 0 舍 1 入 因为二进制的 1 对于十进制数来说, 实际上已经过半 例如, 观察浮点数 19.2F 的 0 舍 1 入性 : = = //32 位浮点数 = //32 位浮点数尾数 1 入 于是得到浮点数的一个表示, 尤其关注其尾数部分 : 0, , 浮点数尾数的最后, 在浮点数尾部, 其最后三位加上待抛弃的那一位, 是 001,1 这个待抛弃的 1, 作为二进制数中的 过半 数, 实施进位的结果, 尾数最后三位就变成了 010(001+1) 了

34 162 C++ 程序设计教程详解 过程化编程 在任何浮点数做存储操作的时候都会面临舍入操作, 所以, 这也让我们看到了二进制浮点数的数值只能维持其邻域的模糊性, 而不能保证其绝对精确性 规格化实例例如, 十进制数 0.6, 对于一个近似的二进制数表示, 转换成规格化二进制数为 : 0.6 = (2)= ,0011,0011,0011,0011, 它比老老实实表示的 23 位尾数 ,1001,1001,1001,1001,101 多了一位精度 计算机在存储 32 位规格化浮点数的尾数时, 抹掉小数点前面的 1; 而取出该数时, 则在其取出尾数的基础上再加上 1 因此 23 位尾数, 加上省略的 1 位, 其精度 ( 这里的精度与有效位概念是一致的 ) 为 24 位 2. 阶码设计 阶码与尾数的平衡至于阶码位, 则可多可少 阶码位越多, 尾数位就越少 例如, 阶码若用 5 位表示, 则尾数就可以用 26 位, 加上符号位, 拼成 32 位 阶码的 5 位只能表示 2 5 =32 个幂次方值, 按正负各半, 可以表示二进制小数的位移 16 位, 表示能力小于 10 5, 即只能使十进制小数偏移约 5 个小数点位置 这对表示大数不利, 但对表示高精度数有利 例如, 表示常数 π 比较适合, 但表示大富翁的上百亿存款就不够了 阶码如果用 10 位表示, 则尾数只能用 21 位了 阶码的 10 位可以表示 2 10 =1024 个状态, 按正负各半, 可以表示约 次方 ( ) 大的数, 但是尾数 21 位只能表示 6 位精度了 一个有 100 多位的大数, 却只有 6 位有效数, 只适合表示向领导汇报的数字, 不适合进行科学计算了, 因为精度丢失未免太大了点 一个符合精度要求的数 ( 要求较长的尾数 ), 却不能在某个区间表示 ( 阶码长度不够 ), 那就不能做正常计算 ; 而一个绝对值很大的数 ( 要求较长的阶码 ), 却只有很小的精度 ( 尾数长度不够 ), 这个数就不大有用 在科学计算中, 既要很强调精度, 又要兼顾各种区间的数值表示, 所以有效位数和阶码的长度在设计中是一对矛盾 经过专家论证, 所定出的 IEEE 国际标准 754 的浮点数规范, 是取得了有效位数与尾数长度之间的一个平衡, 以利于用 32 位数最充分地表达一个小数 8 位阶码意味着 2 8 =256 个阶码状态, 可以表示 (10 38 ) 的数值范围,23 位尾数相当于 2 23 ( 10 7 ) 可以表示约 7 位精度 阶码设置二进制小数规格化之后, 尾数的精度从 23 位提升到 24 位, 但是牺牲了浮点数 0 的规格化表示 因为规格化要求小数点前面 1 位必须是 1, 所以, 即使整个尾数部分都为 0, 其浮点数的有效值也为 1, 结果规格化的浮点数都非 0 为了能表示二进制浮点数中的 0, 除了规格化表示之外, 还保留了非规格化表示形式 标准 32 位浮点数 ( 单精度 ) 规定, 浮点数的阶码为 8 位 ( 表示为有符号整数, 范围在 -128~127), 规格化数的阶码范围在 -126~127 所以规格化数的阶码最小为-126, 而不是 -128 当阶码值为 -127 时, 表示阶码为 -126 的非规格化 (denormalized) 数 所以, 非规格化数只能表示非常靠近 0( 含 0) 的小数, 不能表示幂次方为正的大数

35 第 3 章数据类型 163 当阶码值为 -128 时, 用来表示特殊浮点数 32 位浮点数在计算机内以规格化数表示, 还是以非规格化数表示, 还是以特殊浮点数表示, 是由机器自动决定的 作为一般的计算结果, 都表示以规格化数 ; 当在计算时, 遇到一个非常接近 0 的数, 以至于用规格化数难以表示时, 机器便会自动以非规格化数表示 ; 当遇到一个非法计算, 或者计算溢出时, 便会以特殊浮点数表示 0 与非规格化非规格化数就是不做规格化的二进制小数 它用阶码值 -127 来表示固定的 2-126, 相当于一种定点数 其尾数也不隐含整数 1, 所以有效值不省略小数点前面的 1, 只用 23 位尾数, 于是就可以表示全 0 的尾数了 0 乘以 次方为 0 所以, 当非规格化数 ( 阶码为 -127) 的尾数全 0 时, 该数就是浮点数 0( 即 0, , ) 如果浮点数 0 也是由全 0 位码实现, 那么浮点数也可以当做逻辑数操作了 :0 代表 false, 非 0 代表 true, 这将给语言带来数系之间更广泛的包容 为了使浮点数 0 与整数 0(32 位全 0 位码 ) 统一, 就将浮点数的 0 也用全 0 位码表示 这就需要对所有浮点数的原阶码值作偏移 存储浮点数时, 对所有阶码作 +127 的偏移操作 这样一来, 浮点数 0 的阶码 -127 加上 127 就偏移为 0, 加上符号位与尾数都为 0, 便得到全 0 的位码了 任何浮点数从存储中取出时, 其阶码再做一个 -127 的逆操作, 就将该数又还原为能读懂的浮点数了 这在理解上并不难, 就好比对于一个慢了 10 小时的钟, 看见的是 1 点钟, 对所有钟点都加上 10 个小时去看, 认定为是 11 点钟一样的 3. 规格化数 表示形式存储为规格化浮点数时, 需要额外做两件事 : 一件是获得 24 位尾数, 并剔除第一位存入 ; 另一件是对阶码做 +127 操作, 再存入 例如, 十进制数 35.6 转换为二进制数, 存入到计算机中时, 如下过程描述 : 35.6 = (2) // 转换成二进制数 = // 二进制数规格化 = 0, , // 准备机内表示 = 0, , // 阶码 +127, 尾数剔除 1 = // 最终机内表示其中机内表示中的 2 个逗号将浮点数分隔成三段, 第一段的 0 表示该数为正数, 第二段 为指数 5 加上 127 所得, 第三段是规格化后的 23 位尾数 如果需要输出而将其取出, 则做逆操作 : 阶码减去 127 得到 5, 尾数加上 1 得到 , 又还原为本来的数值了 如果仅仅是变量赋值参与计算, 则原浮点数格式不变 最大数非规格化数都是指数幂次在 -127 的, 即非常靠近 0 的数 比最微细规格化数还要小的数才用非规格化数表示 32 位浮点数能表示的远离 0 的最大数, 则一定得用规格化数来描述

36 164 C++ 程序设计教程详解 过程化编程 当阶码最大 (127), 尾数也最大 (24 位全 1) 时, 浮点数的绝对值达到最大 即 : 0, , // 机内码 = 0, , // 取出时, 阶码 -127, 尾数 +1 = // 折合二进制数 = ( ) ± 注意其机内码阶码是加上了 127 的值 表 3-04 浮点类型说明中的 float 型数的表示范围即为 32 位浮点数的最大值 如果浮点数为负, 则为最大浮点数负值 规格化近 0 数对于规格化数, 其最小 最接近 0 的数值是多大呢? 对于一个 24 位精度的不小于 1 的二进制数, 应取其阶码最小值 (-126), 尾数最小值 (23 位尾数全 0), 这时候其内部表示为 : 0, , // 机内码 = 0, , // 取出时, 阶码 -127, 尾数 +1 = // 折合二进制数 ± 注意机内阶码 故为 1 见表 3-04 的规格化近 0 数 4. 非规格化数 近 0 数因为尾数可以取到比 1 更小, 阶码与规格化的最小阶码一致, 所以非规格化数能够比规格化数表示更接近 0 的数 当尾数取全 0 时, 则该浮点数为 0; 当尾数的 23 位取 22 个 0, 最后 1 位为 1 时, 其尾数的值相当于 2-23, 再迭加上阶码的值, 则其数值为 : 0, , // 机内码 = 0, , // 取出时阶码 -127 = // 折合二进制数 = ± 因为尾数中只有一个非 0 位, 有效位只有 1 位, 所以, 非规格化数的精度比规格化数要差 越靠近 0 的数, 精度越差 近规格化数非规格化小数最大也只能表示尾数全 1, 阶码为 -126 的数, 此时, 非规格化数最大, 最接近规格化数 即 : 0, , // 机内码 = 0, , // 取出时阶码 -127 = // 折合二进制数 = ( ) //<2-126

37 第 3 章数据类型 相当于对机内码做二进制数运算, 令规格化近 0 数减 1 得到最大的非规格化数 所以非规格化数的最大数正好与规格化近 0 数衔接上 非规格化数的阶码用 -127 表示 2 的 -126 次幂, 在技术上恰好与规格化数衔接 5. 特殊浮点数 概说当阶码为 -128 时, 表示的数是特殊数 特殊数有两种, 一种是 ±, 用 Inf 表示 ; 一种是无意义数 (Not a Number), 用 NaN 表示 特殊数不是通过赋值得到的, 而是计算机在运行过程中因操作异常所致 当浮点运算上下溢出时, 得到 ± 的特殊数 表示为尾数全 0, 阶码为 -128 当然经过 +127 操作之后, 实际的机内码为全 1 最简单的 ± 可以从 ±1.0 除以 0.0 得到 + 符号位为 0,- 符号位为 1, 以示区别 无意义数在数学上是没有讨论价值的数, 例如,0.0 除以 0.0, 或者非实数等 当阶码为 -128, 尾数第一位为 1 时, 便为无意义数, 或者称非数 尾数只要第一位为 1, 其他任何尾数组合都是无意义数 当浮点数运算得到一个特殊数时, 如果再做计算, 便将会得到运行错误 这与整数计算略有不同 整数计算中, 如果某数除以 0, 将立即得到一个运行错误, 使程序中断运行 而浮点数计算中得到一个特殊数时, 只要不再以该结果继续计算下去, 程序仍将继续运行 测试代码 下面是产生浮点特殊数的测试代码 //X0308.cpp //test special float format #include<iostream> #include<iomanip> using namespace std; // void print(float f){ int* p = (int*)&f; for(int i=31,a=*p; i>=0; i--) cout<<(a>>i & 1); cout<<" "<<f<<"\n"; }// int main(){ cout<<scientific<<setprecision(18)<<uppercase;

38 166 C++ 程序设计教程详解 过程化编程 print(0.0f); // 正 0 print(-0.0f); // 负 0 cout<<(-0.0f==0.0f? "-0.0==0.0\n":"-0.0!=0.0\n"); // 正负 0 比较 print(1.0f/0.0f); print(-1.0f/0.0f); print(0.0f/0.0f); // 正无穷 Inf // 负无穷 -Inf //0 除 0 得到无意义数 NaN float f = e+14f; int* pf=(int*)&f; print(f); (*pf)++; // 格式化微小数的尾数增量 print(f); (*pf)++; print(f); f *= 5.67E+57f; // 上溢导致无穷大 Inf print(f); f = e-33f; f *= 5.621e-8f; // 微细化导致产生非规格化数直至 0 print(f); }= 得到结果为 : E E == Inf Inf NaN E E E Inf E-41 代码解释代码是对 32 位 float 类型的浮点数进行的操作 输出采用 print 函数调用的方式 函数在执行输出的时候, 是将 32 位浮点内码与浮点值一并输出, 这样便于观察和比较 通过整型数的位操作, 可以访问内存字节所表示的二进制数中的每一位 要将浮点数的内码逐位输出, 需先将浮点数的内存空间看做 32 位的二进制整数, 然后对其实施位操作, 来获得其每一位的值 因为 C/C++ 浮点数作为数据类型的实体本身是不能做位操作的, 只有整型数可以做位操作 函数 print 中, 为了逐位输出浮点数的二进制内码, 先采用整型指针指向浮点数内存空

39 第 3 章数据类型 167 间, 然后通过整型指针的间接访问 ( CH6.1.4 间接访问 ) 获得该空间的 32 位整型数 再对整型数做位操作, 从而逐位输出之 整型指针定义为 int* p, 初始化为浮点变量的地址 &f 因为指针也有类型的分别, 所以在初始化时, 要先将浮点变量的地址转换成整型实体地址, 即 (int*)&f 获得指针指向的整数值, 使用指针的间接访问操作 *p, 因而使用 int a=*p 位操作 >> 是对整型数进行右移操作 a>>1 表示整型变量 a 右移 1 位, 若 a 原先为 5, 则右移 1 位后变成了 2( CH3.1.4 位操作 ) 位操作 & 表示逐位与操作 a>>i & 1 表示整型变量 a 在经过 i 位的右移后 ( 将右边第 i+1 位移到了右边第 1 位 ), 再与 1 做位与操作, 从而得到结果非 0 即 1, 该结果实际上便是右边第 i+1 位的 01 值 输出这个值即是输出右边第 i+1 位的值 如果 i 循环从 31 到 0, 则完成从最高位 ( 右边第 32 位 ) 到右边第 1 位逐位输出 结果解读程序首先将 +0 与 -0 输出, 以展示其差别 随即又输出其比较的结果是相等 浮点数不是二进制补码, 所以存在正负 0 的差别, 但是正负 0 在比较判断中是忽略其符号位的 程序然后输出正负无穷大, 可以看出计算机表达无穷大用的特殊符号 要注意的是, 不同的编译器, 表达特殊数的方式是不同的 当执行 0.0/0.0 之后, 便获得了一个 NaN 特殊数 接着对浮点数的规格化最小微粒的增量进行了展示 先赋一个规格化小数, 然后对尾数加 1( 这个加 1 是通过整型指针的间接访问完成的 ), 然后输出之 比较与前一个浮点数的差别, 可以看到最小微粒的增量, 其实也是一个相当的数量值 后面便是展示浮点数的上溢 上溢得到一个正无穷大 同理, 上溢也可能从负方向得到负无穷大 最后, 当浮点数计算得到充分接近 0 的数时, 便会自然地以非规格化数表示 若再小下去, 最后便会得到 三种浮点型 1. 浮点类型计算机中的浮点数是科学记数法的标准二进制表示形式, 它通过阶码的变动, 具有了浮动的数据区间和一定精度之实数的表达能力, 是一种相对定点数和整数能够更好地完成科学计算任务的数据表达方式 对一些科学计算来说,32 位浮点数虽然比 32 位整型数表示的范围要宽, 但是总的精度却比不上 32 位整型数了, 加之 32 位浮点数在科学计算中, 表示范围还是显得有限, 便需要更高精度和范围的浮点数处理 C/C++ 迎合了这种要求, 提供了三种标准浮点型数的支持 float 表示 32 位浮点型 ;double 表示 64 位浮点型 ;long double 1 表示 80 位浮点型 1 long double 数只有在更高 C++ 版本中才有完整实现 在 VC 6,BCB6,G++4 中, 虽然都实现了 80 位长, 但实际最大阶值仍为 double 型阶值, 只是提高了一些精度而已

40 168 C++ 程序设计教程详解 过程化编程 double 关键字虽然没有一点浮点的意思, 但是它的双倍性词意, 正是要表达在单精度的 float 之上, 具有双倍精度的浮点型之意 ; 同样,long double 表示加长的或者扩展的双精度浮点型, 而不是在双精度的基础上的再加倍 (128 位 ) 之意 在双精度浮点型 (double) 中, 有 1 位符号,11 位阶码,52 位尾数, 共 64 位, 占 8 个字节 ; 在长双精度浮点型 (long double) 中, 有 1 位符号,15 位阶码,64 位尾数, 共 80 位, 占 10 个字节, 如图 3-01 所示 (float) (double) (long double) 图 3-01 各种浮点数的内部表示形式 2. 双精度数表示双精度浮点数的表示原理与单精度浮点数 (32 位 ) 相同, 只是阶码位数不同, 尾数位数不同, 所表示的精度要比 float 大不仅仅是一倍 双精度浮点数的规格化数的阶码表示范围为 -1022~1023, 而 表示非规格化数, 表示特殊浮点数 类似地, 浮点数的阶码在存入操作时要做加 1023 操作, 取出时做减 1023 操作 尾数的位数虽然只有 52 位, 但是与 32 位浮点数同样的原因, 规格化数的精度却有 53 位, 有 1 位整数位在规格化时省出来了 例如, 对于双精度浮点型变量定义 : double d = ; 可得 d 的内部表示为 : = 0, , 其中阶码 为 所得 按照这个原理, 双精度浮点型的最大数, 是当阶码为 1023, 尾数为全 1 时所得 即机内码 : 0, , 规格化近 0 数, 是当阶码为 -1022, 尾数为全 0 时所得 即机内码 : 0, , 而非规格化最大数, 是当阶码为 -1023, 尾数为全 1 时所得 这个数与规格化近 0 数几乎相等 若非规格化数加上 ( ), 则完全相等 其机内码为 :

41 第 3 章数据类型 169 0, , 非规格化近 0 数, 是当阶码为 -1023, 尾数为 51 个全 0 加上最后一个 1 即机内码 : 0, , 如表 3-04 所示 3. 长双精度数表示 长双精度浮点型是比双精度浮点型更高一级的浮点型, 精度已经高到不稀罕那尾数节省下来的那一位 更何况规格化中的那一位不是白白节省的, 而是在存储和取用时, 用减去和加入操作的代价去换的 对于短浮点数, 很计较精度, 很看重这省出的一位 但是对于长浮点数, 精度已经很高了, 比起精度更看重其操作性能 这时候, 就不省这一位了 长双精度数的国际标准正是这样做的 或许, 现代人再来设计 float 的内部结构, 不会省那一位, 因为有后面两种浮点数类型可做选择, 正好在小精度计算中也强调一下性能 长双精度浮点数的正规数的阶码表示范围为 ~16383, 并且没有非规格化数表示的必要, 表示特殊浮点数 当然, 阶码的飘移操作还是有的, 也就是说, 浮点数在作存入操作时, 阶码要加 16383, 作取出操作时要减 所以同样对于 这个浮点数, 长双精度浮点型数内部是这样表示的 : = 0, // 符号 , // 阶码 // 尾数 其中的阶码是在 5 的基础上做了 的偏移所得 从中可以看到, 尾数头上那一位没有省略 长双精度浮点数所能表示的最大数, 是在阶码为 16383, 尾数为全 1 时达到的 即机内码 : 0, // 符号 , // 阶码 // 尾数 长双精度浮点数所能表示的近 0 数 ( 不分规格化与非规格化数 ) 是在阶码为 , 尾数为全 0 加上最后一个 1 时达到的 即机内码 : 0, // 符号 , // 阶码 // 尾数 但是, 这样的表示不是很有用, 在不损失精度的前提下, 也就是尾数仍然保持有 64 位有效, 这时候的近 0 数应在阶码 , 尾数全 1 时达到 也就是将其看做规格化数, 为了保证精度而已, 这在表 中都可以看到

42 170 C++ 程序设计教程详解 过程化编程 4. 浮点数表示范围 所有浮点型的表示范围, 我们用表 3-04 来说明 表 3-04 浮点类型说明 类型类别 float double long double 说明 单精度 双精度 长双精度 位数 32 位 64 位 80 位 长度 4 字节 8 字节 10 字节 表示范围 ± ± ± 规格化近 0 数 ( 精度保证 ) ± ± ± 非规格化近 0 数 ( 损精度 ) ± ± ± 阶码 8 位 11 位 15 位 尾数 23 位 52 位 64 位 二进制有效位数 24 位 53 位 64 位 十进制有效位数 7 位 15 位 18 位 规格化数阶值范围 -126~ ~ ~16383 非规格化数阶值 阶码偏移 NaN 阶值 浮点数问题 1. 精度丢失 范围溢出浮点数的上溢是指绝对值够大, 大到浮点型没有办法表示而趋无穷大 上溢可能是正无穷大, 也可能是负无穷大 - 浮点数的下溢是指绝对值趋向于 0 在运行中, 产生的上溢作为特殊浮点数看待, 产生该数则免不了会导致计算结果的异常 产生下溢也会导致计算无法进行下去 例如 : float f = e300F; double d = e1000; long double ld = E5000L; float f2 = 3.2e-28; f2 *= 3.2e-28; d = -3.9e-300; d *= 123e-40; // 该数无穷大 // 该数无穷大 // 该数无穷大 // 产生上溢, 得到负无穷大 // 产生 -0 下溢 类型与精度如果浮点数的类型表示错了, 会导致数值的精度受损 例如 :

43 第 3 章数据类型 171 long double ld1 = 19.2; long double ld2 = 19.2L; 则 ld1 与 ld2 变量在其内部表示的尾数是不同的 : ld1: ld2: 可以看到,ld1 的尾数因为是由双精度数赋值而来, 在表达长度以外的地方以 0 填充, 显然精度不及 ld2 精度丢失程度由于参加运算的数据类型可能先要转换成另外的数据类型 ( 由低精度向高精度转 ) 进行中间运算, 然后再转换回到低精度上去, 因此有一个从高精度数向低精度数转换的问题, 转换中可能会引起精度丢失 例如, 下列程序说明高精度类型的数赋值给低精度数据类型的实体, 造成了不同程度的精度丢失 //X0309.cpp // 精度丢失程度 #include<iostream> #include<iomanip> using namespace std; // int main(){ cout<<setprecision(9)<<fixed; // 在小数区域显示精度丢失的程度 float f=7.0/3; // 用 double 精度值给 float 变量赋值, 引起精度丢失 int a=7.0/3; // 用 double 精度值给 int 变量赋值, 引起精度丢失 cout<<"double :"<<7.0/3<<"\n"; // 按 double 精度正常输出 cout<<"float :"<<f<<"\n"; cout<<"integer:"<<a<<"\n\n"; // 在整数区域显示精度丢失的程度 f = /3; a = /3; cout<<"double :"<< /3<<"\n"; cout<<"float :"<<f<<"\n"; cout<<"integer:"<<a<<"\n"; }//==================================== 其运行结果为 : double : float : integer:2 double :

44 172 C++ 程序设计教程详解 过程化编程 float : integer: 将 double 型数 转换为 float 数的时候, 因为 float 的有效位数有限, 所以精度丢失, 计算没有办法在 double 层次上进行, 只能在 float 的单精度上进行 显示该 float 变量的值 这个数是 32 位浮点数在转换为十进制浮点数时保留 9 位小数的结果, 显然没有 double 数精度高 同样将 double 型数赋给 int 型变量, 截去了所有小数部分, 引起更大的精度丢失 然而引起更大精度丢失的原因不是因为整型数的精度比 float 浮点数小, 而是表现精度值的区域不在整数部分 接下去的运行结果说明了这一点 将一个在整数区域充分大的 double 型数分别赋给 float 浮点型变量和 int 整型变量, 观察两者的精度丢失情况 可以看到 float 在整数部分中已经丢失精度, 而 int 变量至少保留了整数部分的精度 因为 float 的表示区域大于整型, 而又与整型有同样长度的数据表示, 所以其有效位少于整型数 相当于其在数轴上的数值分布更加稀疏, 所以实际精度表示不及整型 但是, 在 0 到 1 区间, 整型数不具有表现力, 这时候,float 型数便体现出 更高 的精度了 2. 浮点数比较 浮点数不精确浮点数可以进行比较操作, 但是浮点数由于两个原因而使比较的不精确 : (1) 是浮点数类型在精度表示能力上的问题引起 例如, 两个 9 位小数的十进制数, 前 8 位相同, 但表示成 float 型浮点数之后, 两个浮点数没有差异 (2) 是十进制数转换成二进制浮点数的不精确性引起 例如, 十进制数 0.6 在浮点数表示中只能近似表示 这些原因导致了浮点数在相等性比较中失败 例如用下列程序说明 : //X0310.cpp // 精度误差影响比较 #include<iostream> using namespace std; // int main(){ float f1 = ; float f2 = ; cout<<(f1!=f2? "not same\n" : "same\n"); float g = 0.6; double d = 0.6; cout<<(g==d? "same\n" : "not same\n"); }//====================================

45 第 3 章数据类型 173 其运行结果为 : same not same 1 当你满怀信心地读完程序后, 想象出的运行结果却与真实的运行结果大相径庭, 你有何感想? 代码分析首先, 由于十进制单精度浮点数的有效位数约为 7, 两个前 7 位相等而后面不同的数有可能在计算机中表示为同一浮点数, 因而判断 f1 和 f2 为不相等失败 在编程计算中,f1 可能来自一个 double 型计算结果, 而 f2 可能来自另一个不同的 double 型计算结果, 当它们用 float 型表示时, 由于精度受限而不能分辨出其差异, 这就是错误结果的根源 如果要分辨值的差异, 则应该用表示能力更强的 double 或 long double 来表示这两个数 其次, 由于 float 和 double 的精度不同, 比较操作总是先要将两个相容的类型化成相同的类型再进行比较, 所以相同的浮点数初始化给不同浮点类型的变量, 可能表示不同的浮点数, 判断 g 与 d 相等居然也会遭到失败 解决方法一为了避免这类问题, 在单一计算中请统一使用一种浮点型 ( 建议使用 double), 而不要混用不同精度的浮点数 对 C++ 来说,float 已是昔日黄花, 除了为一些 C 程序作过渡, 在新编的程序中很少有大的用处 在 32 位计算机中, 浮点计算装置被默认设置成 double, 若用 float 型计算, 反而需要来去转换的时间开销 况且 double 的精度完全覆盖了 float, 混进 float 型只会添乱 按程序运行实测, 许多 double 的算术计算并不比 float 慢 另外, 不要用不同的数据类型与浮点型数进行比较 例如, 用整型数与浮点型数进行相等性比较, 那是不合适的 解决方法二虽然用同一个浮点型, 两个数值相等性的比较也要慎重 因为两个 相等 的浮点数可能来自不同的计算 由于浮点数在计算机内实际上是一个近似表示 ( CH3.3.1), 在手工计算看来为正确的结果, 在计算机中运算未必能得出正确的结果 例如 : //X0311.cpp // 浮点数的比较 #include<iostream> #include<iomanip> #include<cmath> using namespace std; // int main(){