2.1　变量与基本数据类型

当编写程序时要把变量存储在计算机中，但是计算机必须要知道存储的是什么样的数据类型，因为存储一个简单数字和存储一个字符或者是一个大的数字，占用的内存数量并不相同，它们被解释的方法也不相同。

计算机的内存是以字节为单位来组织的。字节是在C++中可以操控的最小单位，一个字节可以存储一个很小的数据：一个字符或者一个整数（范围是0～255）。另外，计算机也可以通过组合字节来操作一些复合类型，比如长整型或者一些其他数字。

C++定义了几种基本类型：字符型、整型、浮点型等。该语言还提供了允许自定义数据类型的机制，标准库利用这些机制定义更复杂的类型，比如可变长字符串string、vector等，还能修改已存在的类型以形成复合类型。

2.1.1　什么是变量

变量是指在程序的运行过程中随时可以发生变化的量。变量是程序中数据的临时存放场所。在代码中可以只使用一个变量，也可以使用多个变量。变量中可以存放单词、数值、日期以及属性。由于变量能够把程序中准备使用的每一段数据都赋予一个简短、易于记忆的名字，因此它们十分有用。变量可以保存程序运行时用户输入的数据、特定运算的结果以及要在窗体上显示的一段数据等。简而言之，变量是用于跟踪几乎所有类型信息的简单工具。

说明 在对程序进行编译连接时，由编译系统给每一个变量名分配一个对应的内存地址。从变量中取值，实际上是通过变量名找到相应的内存地址，从该存储单元读取数据。

变量有两种类型，属性变量和用户自己建立的变量。当在窗体中设计用户界面时，VC++6.0会自动为产生的对象（包括窗体本身）创建一组变量，即属性变量，并为每个变量设置其缺省值。这类变量可直接使用，比如引用它或给它赋新值。用户也可以创建自己的变量，以便存放程序执行过程中的临时数据或结果数据等。在程序中，这样的变量是非常重要的。后面将介绍这类变量的创建和使用方法。

变量又分很多种数据类型，C++定义了几种基本类型：字符型、整型、浮点型等。比如，要统计人数必须用整数，不能说0.2个人。整数还有一定的大小范围，比如要统计一个工厂、一个学校的人数，也就是几千或几万人，使用整数（0～±32767）就可以了。如果要统计一个省的人数，整数就不够用了，就要使用长整数（-2147483648～+2147483647）。而要表示商品的单价，则须使用带小数的数（实数）。小数同样也有范围大小问题，根据大小将实数分为单精度数和双精度数两种。如果在程序中要表示某人的姓名或某个字符，就要用字符类型的变量。

这些不同场合使用的不同类型及不同大小的数就是数据类型。在程序中要根据实际使用需要来定义不同的变量类型，图2.1展示了C++定义的各种数据类型。

不同的变量类型所占用的内存长度以及所表示的数值范围是不相同的，表2.1罗列了各种类型的数据表示范围。

2.1.2　如何定义变量

和其他高级语言一样，在C++语言中用来对变量、符号常量、函数、数组、类型等数据对象命名的有效数字符序列统称为标识符。简单地说，标识符就是一个名字。

C++语言规定标识符只能由字母、数字和下划线3种字符组成，且第一个字符必须为字母或下划线。下面列出的都是合法的标识符，可以作为变量名：

sum, average，_total, Class, day, month, Student_name, tan, lotus_1_2_3

下面是不合法的标识符和变量名：

M.D.Smith，123，#33，3F65，a＜b

注意 编译系统将大写字母和小写字母认为是两个不同的字符。因此，sum和SUM是两个不同的变量名，同样，Class和class也是两个不同的变量名。一般来说，变量名用小写字母表示，与人们日常习惯一致，以增加可读性。

C++标准中没有规定标识符的长度（字符个数），但是各个C++编译系统都有自己的规定。有的系统（如IBM-PC的MSC）取8个字符，假如程序中出现变量名长度大于8个字符，则只有前面8个字符有效，后面的将不被识别。例如，有两个变量：student-name和student-number，由于二者的前8个字符相同，系统认为这两个变量是一回事而不加区别。可以将它们改成：stud-name和stud-num，以使之区别开。因此写程序时应了解所用系统对标识符长度的规定，以免出现上面的混淆，这种错误并不反映在编译过程中（语法无错误），但运行结果是不正确的。

在C++中，变量必须先定义后使用。变量定义的格式是：

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

各类变量的定义见表2.2。

根据实际情况，变量可以边定义边赋值（称就近赋值），也可先定义后赋值。具体请参见实例2.1（源代码\Chapter 2/2_1）。

【实例2.1】 变量定义规范。

#include＜iostream.h＞

#include＜stdlib.h＞

int main（）

{

int a, b； 　//先定义后赋值

a=32760；

b=60； 　//赋值

long c=123456789，d=123； 　//边定义边赋值

double x=1.23，y=2.0；

char c1=65，c2=97；

cout＜＜"\na+b="＜＜a+b；

cout＜＜"\na+b="＜＜（long）a+b； 　//将a强制类型转换为长整型

cout＜＜"\nx*y="＜＜x*y；

cout＜＜"\nc1="＜＜c1＜＜"c2="＜＜c2；

system（"pause"）； 　//暂停

return 0；　 //返回值

}

【输出结果】实例2.1的输出结果如下。

a+b=32820

a+b=32820

x*y=2.46

c1=A c2=a

【代码剖析】

实例中分别采用先定义后赋值以及边定义边赋值两种方式对变量进行声明。

2.1.3　整型

整型数据类型是C++中最常见的一种数据类型，本小节将讲述C++基本数据类型中的整型数据类型。

1. 整型数据在内存中的存放形式

数据在内存中是以二进制的形式存放的。如果定义了一个整型变量i：

int i； //定义为整型变量

i=14； //给变量i赋值14

十进制数14的二进制形式为1110，在32位系统中，一个整数默认情况下要占用4个字节（32位）的内存单元。比如，整数14的二进制表示为（1110） ₂ ，在内存中的存放方式如下（省略高16位），如图2.2所示。

对于-14，根据计算机对于有符号数的规定，存放数据的内存单元的最高位充当符号位，而其他位用于存放数据。因此-14似乎可以按照如图2.3所示的方式存放。

但是实际上这样的存放方式是错误的，因为将上面两个整数的二进制形式相加并不为零。因此对于这种情况，为了解决负数存放以及负数的算术运算问题，整数的数值在内存中是以补码的方式表示的。补码是根据原码而来的，所谓原码就是一个整数的绝对值的二进制表示，比如（0000000000001110） ₂ 就是14和-14的原码。可以看出，一个正整数和零的补码就是其原码本身；而一个负数的补码则是它的原码取反后再加1的结果。因此，-14的补码应为（1111111111110010） ₂ ，它的最高位是1，表明这是个负数。-14在内存中实际上是这样存放的，如图2.4所示。

补码的求解步骤如下：

□取-14的绝对值14；

□14的绝对值的二进制形式为1110；

□对1110取反得1111111111110001（一个整数占16位）；

□再加1得1111111111110010。

它的补码求解流程如图2.5所示。

2. 整型数据的定义

定义变量的基本格式如下所示：

数据类型标识符变量名；

整型数据类型的标识符是int，因此定义一个整型变量的基本格式如下：

int变量名；

说明 整型类型关键字int与变量名之间要用空格分开，最后必须以分号结束。

比如要定义一个名为a的int型变量，可以按照下面的形式书写：

int a；

如果想一次定义多个整型变量，可以按照以下的格式来定义：

int变量名1，变量名2，……变量名k；

说明 变量名之间要以逗号分开，最后必须以分号结尾。

比如，要定义3个变量a, b，c，可以按照以下的形式书写：

int a, b，c；

它等价于：

int a；

int b；

int c；

当定义一个变量时，系统会为该变量分配一个大小合适的内存单元。因此这个变量是有值的，它的值就是对应的内存单元的值，然而这个值是程序员无法预知的。

如果需要确保变量在定义时具有初始值，就必须在定义变量的同时为该变量赋值。具体方式如下：

int a=数值；

3. 整型常量

1）十进制整数。十进制整数由正号（+）或负号（-）开始，接着为首位非0的若干个十进制数字所组成。若前缀为正号则为正数，若前缀为负号则为负数，若无符号也认为是正数。如38，-25，+120，74286等都是符合书写规定的十进制整数。

当一个十进制整数大于等于-2147483648即-2 ³¹ ，同时小于等于2147483647即2 ³¹ -1时，则被系统看作是int型常量；当在2147483648～4294967295即2 ³² -1范围之内时，则被看作是unsigned int型常量；当超过上述两个范围时，则无法用C++整数类型表示，只有把它用实数（即带小数点的数）表示才能被有效存储和处理。

2）八进制整数。八进制整数首位数字为0、后接若干个八进制数字（十进制数字中的0～7）所组成。在C++语言中，八进制整数的参考格式如下：

0m 　//其中，m为一整数

八进制整数不带符号位，隐含为正数。如0，012，0377，04056等都是八进制整数，对应的十进制整数依次为0，10，255和2094。

当一个八进制整数大于等于0同时小于等于017777777777时，则称为int型常量；当大于等于020000000000同时小于等于037777777777时，则称为unsigned int型常量；超过上述两个范围的八进制整数则不要使用，因为没有相对应的C++整数类型。

3）十六进制整数。十六进制整数由数字0和字母x（大、小写均可）开始，后接若干个十六进制数字（0～9，A～F或a～f）所组成。在C++语言中，十六进制整数的参考格式如下：

0xm或者0Xm 　//其中，m为一个十六进制整数

同八进制整数一样，十六进制整数也均为正数。如0x0，0X25，0x1ff，0x30CA等都是十六进制整数，对应的十进制整数依次为0，37，511和4298。

当一个十六进制整数大于等于0同时小于等于0x7FFFFFFF时，则称为int型常量；当大于等于0x80000000同时小于等于0xFFFFFFFF时，则称为unsigned int型常量；超过上述两个范围的十六进制整数没有相对应的C++整数类型，所以不能使用。

4）在整数末尾使用u和l字母。对于任一种进制的整数，若后缀有字母u（大、小写等效），则硬性规定它为一个无符号整型（unsigned int）数；若后缀有字母l（大、小写等效），则硬性规定它为一个长整型（long int）数。在一个整数的末尾，可以同时使用u和l，并且对排列无要求，如25U，0327UL，0x3ffbL，648LU等都是整数，其类型依次为unsigned int, unsigned long int, long int和unsigned long int。

4. 整型数据的分类

整型变量的基本类型符为int, C++允许程序员在定义整型变量时，在int前增加两类修饰符：一类用于控制变量是否有符号，这类修饰符包括signed（有符号）和unsigned（无符号）；而另外一类用于控制整型变量的取值范围，这类修饰符包括short和long。比如可以按照如下方式定义一个整型变量：

unsigned long int a；

unsigned和long都是数据类型修饰符，如果在定义变量时，不指定signed，也不指定unsigned，则默认为signed，即有符号。实际上，signed修饰符完全可以不写。因此，整型变量根据这种规则可以分为6种，分别为有符号整型、无符号整型、有符号短整型、无符号短整型、有符号长整型和无符号长整型，具体分类如表2.3所示。

1）有符号短整型。有符号短整型的数据类型符为short int，也可以直接使用short作为类型符，它占2个字节的内存单元，数值范围是-2 ¹⁵ ～2 ¹⁵ -1内的整数。

2）无符号短整型。无符号短整型的数据类型符是unsigned short int，也可以直接使用unsigned short作为类型符，它也占用2个字节的内存单元，数值范围是0～2 ¹⁶ -1内的整数。

3）有符号整型。有符号整型的数据类型符是int，它占用4个字节的内存单位，最高位是符号位，当最高位是1时，变量的值是负数，否则为正数。它的数值范围是-2 ³¹ ～2 ³¹ -1内的整数。

4）无符号整型。无符号整型的数据类型符是unsigned int，它与有符号整型一样，占用4个字节的内存单位，但是最高位不是符号位，会参与数值计算。因此无符号整型变量的值是非负的，数值范围是0～2 ³² -1之间的整数。

5）有符号长整型。有符号长整型的数据类型符是long int，也可以缩写为long，它占用4个字节的内存单元，最高位为符号位，只有31位参与数值计算，因此它的数值范围是-2 ³¹ ～2 ³¹ -1内的整数。

6）无符号长整型。无符号长整型的数据类型符为unsigned long int，也可以缩写为unsigned long，它占用4个字节的内存单元，但最高位不是符号位，有32位参与数值计算，因此它的数值范围是0～2 ³² -1内的整数。

关于整型数据分类的说明：

1）在标准C++中，int的定义长度依赖于用户的机器的字长。也就是说，如果用户的机器是32位的，int的长度为32位；而如果用户的机器是64位的，那么int的标准长度就是64位，而VC中__int64是为在32机位机器上实现64位长度的整型数。

2）long从字面上看，应该是64位才更合理，把long当成32位实在是一个历史的包袱。像C#那样新起炉灶的程序语言，由于没有需要支持老代码的问题，因此就把long当作64位来处理了。

3）在32位平台下，long是相对short而言的，long（short）类型是long（short）int类型的简称，sizeof（long）=sizeof（int）=4。int和long的范围虽然一样，但输入/输出格式不同，printf int的格式为%d，而printf long的格式为%ld。

4）考虑到程序的可移植性，还是要将它们区分开来。但当要求的数值范围为4字节时，建议使用int类型，因为第一版的C语言只有一种内置类型，那就是int。

5. 整型数据实例

实例2.2将介绍如何使用整型数据，通过该实例，可以了解在VC++6.0下，各种整型数据的范围和所占内存字节数。

【实例2.2】 使用整型数据（源代码\Chapter 2/2_2）。

#include＜stdio.h＞

#include＜limits.h＞

int main（int argc, char*argv[]）

{

short nShortMin=SHRT_MIN； 　//最小有符号短整型

short nShortMax=SHRT_MAX； 　//最大有符号短整型

unsigned short nUShortMax=USHRT_MAX； 　//最大无符号短整型

int nIntMin=INT_MIN；　 //最小有符号整型

int nIntMax=INT_MAX； 　//最大有符号整型

unsigned nUIntMax=UINT_MAX；　 //最大无符号整型

long nLongMin=LONG_MIN； 　//最小有符号长整型

long nLongMax=LONG_MAX；　 //最大有符号长整型

unsigned long nULongMax=ULONG_MAX；　 //最大无符号整型

printf（"有符号短整型占用内存为%d，其最大值和最小值分别为%d和%d；\n"，sizeof（short），nShortMin, nShortMax）；　 //输出有符号短整型

printf（"无符号短整型占用内存为%d，其最大值为%d；\n"，sizeof（unsigned short），nUShortMax）； 　//输出无符号短整型

printf（"有符号整型占用内存为%d，其最大值和最小值分别为%d和%d；\n"，sizeof（int），nIntMin, nIntMax）； 　//输出有符号整型

//输出无符号整型

printf（"无符号整型占用内存为%d，其最大值为%u；\n"，sizeof（unsigned int），nUIntMax）；

printf（"有符号长整型占用内存为%d，其最大值和最小值分别为%ld和%ld；\n"，sizeof（long），nLongMin, nLongMax）； 　//输出有符号长整型

//输出无符号长整型

printf（"无符号长整型占用内存为%d，其最大值为%u；\n"，sizeof（unsigned long），nULongMax）

return 0；

}

【输出结果】实例2.2的输出结果如下所示。

有符号短整型占用内存为2，其最大值和最小值分别为-32768和32767；

无符号短整型占用内存为2，其最大值为65535；

有符号整型占用内存为4，其最大值和最小值分别为-2147483648和2147483647；

无符号整型占用内存为4，其最大值为4294967295；

有符号长整型占用内存为4，其最大值和最小值分别为-2147483648和2147483647；

无符号长整型占用内存为4，其最大值为4294967295；

【代码剖析】

函数printf是将变量的值显示在计算机屏幕上，在下面的章节中会专门介绍。这里只需要知道printf的功能是将第一个参数的字符串显示出来，并且这个字符串中的%d并不显示，而是在%d的位置上显示printf函数的第二个参数（%d表示这个参数必须是整数）。比如printf（"a=%d\n"，a）；在执行过程中，先显示“a=”，然后再显示变量a的值，最后再显示\n（换行符）。

2.1.4　浮点型

浮点数（floating-point number）又称为实数（real-number），是C++中一种重要的数据类型。本小节将讲述C++基本数据类型中的浮点类型。

1. 浮点数据类型的表示方法

在C++语言中，它有2种表示方法：

1）十进制小数形式，这种形式由数字和小数点组成，比如1.3、54.25、0.01等。当然，也可以省去整数部分，只保留小数点和小数部分，比如.24、.2、.6548等，但是绝对不能没有小数点。

2）指数形式，比如145.235e2表示的是145.235*10 ² ，而2E5表示2*10 ⁵ 。在这种表示方法中，e或者E前面必须有数字，后面必须是整数。比如e3、.e5、32e2.3这些都是错误的指数形式。对于指数形式的浮点数，若将它尾数中的小数点调整到最左边第一个非零数字的后面，则称它为规格化（或标准化）浮点数。如21.6E8和-0.074E5是非规格化的，若将它们分别调整为2.16E9和-7.4E3则都是规格化的浮点数。

2. 浮点数在内存中的存放形式

整数在内存中直接存放的是数值的二进制表示，但由于浮点数取值范围太大，不能直接将实数的二进制表示存放在内存中，因为这样处理太浪费内存。在实际运用中，计算机中的浮点数是按照指数形式存放的。通常一个实数需要4个字节（32位）的内存单元，计算机将这4个字节分为3部分，最高位是符号位，剩下的31位，有一部分存放浮点数的小数部分，另一部分存放浮点数的指数部分。比如对于浮点数123.4567，它在内存中的存放形式如图2.6所示，在存放之前，计算机将123.4567转换为1.234567e3的指数形式，然后再存放。

具体来说，有多少位用来存放小数，有多少位用来存放指数，在C++中没有明确规定，它是由C++编译器决定的。从程序员的角度来说，这也是无须知道的细节，程序员只需要知道的是，小数部分占的位数越多，它能表示的精度越高；而指数部分占的位数越多，它能表示的值就越大。

3. 浮点数的分类和定义

浮点数变量的定义格式与整型变量一样，不同之处在于浮点数的关键字不同。浮点数变量总共有3类，分别是单精度浮点数类型、双精度浮点数类型和长双精度浮点数类型。

1）单精度浮点数类型。单精度浮点数类型的关键字是float，它占用4个字节（32位）的内存单元。由float定义的变量的取值范围为10 ^-37 ～10 ³⁸ 。float类型变量的定义可以参考以下代码：

float fNum=3.1415；

2）双精度浮点数类型。双精度浮点数类型的关键字是double，它占用8个字节（64位）的内存单元，由double定义的变量的取值范围为10-307～10308。double类型变量的定义可以参考以下代码：

double x=123.46679；

double y=564879.3589445；

3）长双精度浮点数类型。长双精度浮点数类型的关键字是long double，它占用8个字节（64位）的内存单元，由long double定义的变量的取值范围为10 ^-307 ～10 ³⁰⁸ 。long double类型变量的定义可以参考以下代码：

long double x=123.46679；

long double y=564879.3589445；

说明 1）long float实际上就是double，因此没有long float类型；

2）以上3种浮点数据类型中，float的精度最低、long double的精度最高；

3）所有的浮点数据类型常量都是按照double处理的。

4. 浮点数的精度范围

前面已经讲过，在很多情况下，无法用一个二进制数精确地表示一个十进制浮点数，这主要是因为float、double和long double这3种数据类型中只用有限数位存放小数。存放小数部分的位数越多，数据的精度就越高，浮点数的精度决定了浮点数变量所能表示的有效数字的个数。表2.4列举了这3种浮点数所能精确表示的数字个数和精度范围。

5. 浮点数实例

实例2.3将介绍如何使用浮点数数据，通过该实例（求圆面积）可以了解在VC++6.0下，各种浮点数数据所占的内存字节数。

【实例2.3】 使用浮点数数据（源代码\Chapter 2\2_3）。

#include＜stdio.h＞

#define PI 3.1415f

int main（int argc, char*argv[]）

{

float r1=5.0； 　//定义单精度变量

double r2=3.2546；　 //定义双精度变量

long double r3=5.68794632； 　//定义长双精度变量

float area1=PI*r1*r1；　 //面积1

double area2=PI*r2*r2； 　//面积2

long double area3=PI*r3*r3；　 //面积3

//输出单精度

printf（"单精度浮点数占用内存为%d，半径为%f的圆面积为%f\n"，sizeof（float），r1，area1）；

//输出双精度

printf（"双精度浮点数占用内存为%d，半径为%f的圆面积为%f\n"，sizeof（double），r2，area2）；

//输出长双精度

printf（"长双精度浮点数占用内存为%d，半径为%f的圆面积为%f\n"，sizeof（long double），r3，area3）；

return 0；

}

【输出结果】实例2.3的输出结果如下所示。

单精度浮点数占用内存为4，半径为5.000000的圆面积为78.537498

双精度浮点数占用内存为8，半径为3.254600的圆面积为33.276091

长双精度浮点数占用内存为8，半径为5.687946的圆面积为101.636112

【代码剖析】

该实例首先以单精度、双精度和长双精度的类型定义了3个半径，然后通过圆面积公式求出其面积。从结果可以看出，单精度、双精度以及长双精度在VC++6.0下占用内存单元分别为4、8、8。

2.1.5　字符类型

对于一般的数学计算而言，只需要整型和浮点型数据就可以了。但是计算机除了具有数学计算的功能之外，还应该具有输入和显示文本的功能。要处理文本信息，就必须依赖于字符型数据。字符型数据就是用来表示英文字母、符号和汉字的数据。

字符型数据实际上就是整数数据，但是它只占用1个字节（8位）的内存单元。所以字符型数据一共只有256个字符型数值。虽然字符型数据可以参与算术运算，但是计算机通常不对它进行数值式解释，而进行文本式解释，因为字符型数据是用来表示文本信息的。

1. ASCII码

每一个字符都对应着一个值，对于这些字符对应的值，美国国家标准局制定了一个具体的字符编码方案，即ASCII码，它规定了每个字符的具体值，因此字符值又称为字符的ASCII码。

ASCII码使用指定的7位或8位二进制数组合来表示128或256种可能的字符。标准ASCII码也叫基础ASCII码，使用7位二进制数来表示所有的大写和小写字母，数字0～9、标点符号，以及在美式英语中使用的特殊控制字符。

在ASCII码中，0～31及127（共33个）是控制字符或通信专用字符（其余为可显示字符），如控制符：LF（换行）、CR（回车）、FF（换页）、DEL（删除）、BS（退格）、BEL（振铃）等；通信专用字符：SOH（文头）、EOT（文尾）、ACK（确认）等；ASCII值为8、9、10和13分别转换为退格、制表、换行和回车字符。它们并没有特定的图形显示，但会依据不同的应用程序而对文本显示有不同的影响。

32～126（共95个）是字符（32是空格），其中48～57为0～9这十个阿拉伯数字；

65～90为26个大写英文字母，97～122号为26个小写英文字母，其余为一些标点符号、运算符号等。

同时还要注意，在标准ASCII码中，其最高位用作奇偶校验位。所谓奇偶校验，是在代码传送过程中用来检验是否出现错误的一种方法，一般分奇校验和偶校验2种。奇校验规定：正确的代码一个字节中1的个数必须是奇数，若非奇数，则在最高位添1；偶校验规定：正确的代码一个字节中1的个数必须是偶数，若非偶数，则在最高位添1。

后128个称为扩展ASCII码，目前许多基于x86的系统都支持使用扩展ASCII。扩展ASCII码允许将每个字符的第8位用于确定附加的128个特殊符号字符、外来语字母和图形符号。

2. 字符型常量的表示方法

字符型常量的表示方法有2种，第1种是对于那些可以直接输入的字符，比如a、r、T、E、#、1、＆、[等，可以用单引号将其括起来表示其常量。比如'A'表示的是字母A的字符常量；'a'表示的是字母a的字符常量；'#'表示的是符号#的字符常量；而'4'则表示数字字符4的常量。

说明 字符'3'和数字3是不同的，在ASCII表中，字符'3'表示的值是51，而不是3。

第2种是对于那些无法直接输入的字符以及某些特殊字符，需要用单引号括起来的转义字符来表示，比如'\r'、'\n'、'\127'、'\xr5'等。转义字符是以字符'\'开头的一组字符，这一组字符用来表示一个字符。表2.5列举了常见的转义字符。

转义字符表说明：尽管单引号、双引号和\都可以直接输入，但是转义字符用到了\，字符常量需要用单引号括起来，而字符串常量需要用双引号括起来，因此单引号、双引号和\都需要用转义字符表示。字符'\123'的值是99，即（123） ₈ ，不是123；字符'\26'的值是38，不是26；字符'\x12'的值是18，即（12） ₁₆ ，而不是12；字符'\a'就是'a'。

表2.6列举了一些非法的字符常量。

3. 字符型变量的定义

字符型数据类型的关键字是char（即character的前4个字母）。由于字符型数据可以参与算术运算，因此C++语言区分了有符号字符和无符号字符。默认情况下，字符是有符号的。有符号的字符数据的最高位是符号位，取值范围是-128～127；而无符号的字符的数据类型的关键字是unsigned char，取值范围是0～255。字符型变量的定义可以参考以下代码：

char ch；

unsigned char c='D'；

4. 字符型数据实例

实例2.4将介绍如何使用字符型数据，通过该实例，可以了解在VC++6.0下，各种字符型数据的范围和所占内存字节数。

【实例2.4】 使用字符型数据（源代码\Chapter 2/2_4）。

#include＜stdio.h＞

#include＜limits.h＞

int main（int argc, char*argv[]）

{

char cMin=SCHAR_MIN； 　//最小有符号字符型

char cMax=SCHAR_MAX； 　//最大有符号字符型

unsigned char cUMax=UCHAR_MAX； 　//最大无符号字符型

printf（"有符号字符型占用内存为%d，其最大值和最小值分别为%d和%d；\n"，sizeof（char），cMin, cMax）； 　//输出有符号字符型

//输出无符号字符型

printf（"无符号字符型占用内存为%d，其最大值为%d；\n"，sizeof（char），cUMax）；

char cBegin1='A'； 　//声明大写的字母A

char cBegin2='a'； 　//声明小写的字母a

//分别打印出26个大写和小写字母以及对应的ASCII码

for（int i=0；i＜26；i++）

{

if（i%4==0＆＆i！=0）

printf（"\n"）； 　//换行

char cEnd1=cBegin1+i；

char cEnd2=cBegin2+i；

printf（"%c（%d），%c（%d）；"，cEnd1，cEnd1，cEnd2，cEnd2）；　 //输出无符号字符型

}

return 0；

}

【输出结果】实例2.4的输出结果如下所示。

有符号字符型占用内存为1，其最大值和最小值分别为-128和127；

无符号字符型占用内存为1，其最大值为255；

A（65），a（97）；B（66），b（98）；C（67），c（99）；D（68），d（100）；

E（69），e（101）；F（70），f（102）；G（71），g（103）；H（72），h（104）；

I（73），i（105）；J（74），j（106）；K（75），k（107）；L（76），l（108）；

M（77），m（109）；N（78），n（110）；O（79），o（111）；P（80），p（112）；

Q（81），q（113）；R（82），r（114）；S（83），s（115）；T（84），t（116）；

U（85），u（117）；V（86），v（118）；W（87），w（119）；X（88），x（120）；

Y（89），y（121）；Z（90），z（122）；

【代码剖析】

该实例定义了3个变量用于获取最小有符号字符、最大有符号字符和最大无符号字符，然后分别打印出了26个字母的大小写以及对应的ASCII码。

2.1.6　布尔类型

在C中，程序员往往使用一个整型变量来标识一个对象的真假。C++中提供了布尔类型，布尔类型对象可以被赋予文字值true或者false，就是真或假。与C语言中的整型衔接起来看，布尔类型的对象也可以看作是一种整数类型的对象，更好的解释是布尔类型对象将被隐式地转换成整型对象，它们的值即false就是0，而true就是1，同样整型对象也可以向布尔型对象转换。但是它不能被声明成signed、unsigned、short long，否则会导致编译错误。

实例2.5将介绍如何使用布尔类型数据，通过该实例，可以了解VC++6.0下如何使用布尔类型变量。

【实例2.5】 使用布尔类型变量（源代码\Chapter 2\2_5）。

#include＜iostream＞

using namespace std；

int main（int argc, char*argv[]）

{

//此处可看作int型的1，也可写作bool booltest=1

bool booltest=true；

int a=1；

cout＜＜a+booltest＜＜endl； 　//booltest做了隐式转换

booltest++； 　//bool对象允许进行++操作

//booltest--； 　//bool对象不允许进行--操作

cout＜＜booltest＜＜endl；

return 0；

}

【输出结果】实例2.5的输出结果如下所示。

2

1

【代码剖析】

在cout＜＜a+booltest＜＜endl；中booltest隐式转换成int型的副本与a进行+操作。在booltest++；中根据C中非0即真的原则，bool型对象在自增后仍是“真”，所以输出此时booltest的值仍为1，另外booltest--；操作是非法的操作。 iEAHf2Wz1mCXoaE8kubQR9OuzePx3idLSIz+J64o4BtHlVy6VbBe9JvqVx7VOY0g