二进制、八进制、十六进制转换

第五章变量和常量

5.1 从类型到变量

5.1.1 公孙龙的“白马非马”

5.1.2 定义变量

5.1.3 如何为变量命名

5.1.4 如何初始化变量

5.1.4.1 什么时候需要给变量初始化？

5.1.4.2 初始化变量的两个时机

5.1.4.3 通过计算得到初始值

5.1.4.4 变量的取值范围

5.2 变量与内存地址

5.3 常量

5.3.1 几种数据类型常数的表达方法

5.3.1.1 整型常数的表达

5.3.1.2 实型常数的表达

5.3.1.3 字符常量的表达

5.3.1.4 字符串常量

5.3.2 用宏表示常数

5.3.3 常量定义

5.3.4 枚举常量

5.3.4.1 为什么需要枚举类型

5.3.4.2 定义枚举类型的基本语法

5.3.4.3 关于枚举常量的输出效果5.1 从类型到变量

5.1.1 公孙龙的“白马非马”

（该版课程的内容更新及订正均已停止）

旧版课程打包下载

----------------------------------

[想看涵盖“面向对象”、“图形编程”、“泛型编程”……

的“最新2008年版白话C++”课程，请点击！] (另有: 博客版)

故事是春秋时的公孙龙先生说的。

城门上告示：“马匹不得入城”。公孙龙同志骑白马而来，遭拒入。公孙龙一脸正色：“告示上写的是‘马’，而我骑的是‘白马’，难道‘马’等于‘白马’吗？”

守门士兵觉得白马还真不是马，于是放行。

依公孙龙先生的理论认为：如果白马是马，黑马也是马，那么岂不白马等于黑马，所以，不能说白马是马。“白马非马”是中国哲学史上的一桩公案。不过，若是我们从程序的角度上说，可以认为：马在这里表示一种类型，而白马，黑马它们的类型都是马。

白马，黑马具有相同的“数据类型”，但它们都相对独立的个体。从这点说，别说有白黑之分，就算同样是白马，这一匹和哪一匹白马，也是相对独立的个体。

在程序中，“类型”和“变量”的关系正是“马”和“白马”的关系。

如果C或C++有这种数据类型： Horse,那么，定义一匹“白马”的变量应该这样：

Horse AWhiteHorse;

以后我们说不定真的有机会自已定义Horse，不过现在，我们在上一章的学的数据类型是：

char,int,bool 等等。

假设我们需发使用一个有关年龄的变量，在C或C++中是这样定义的：

int age;

现在让我们来事先建立一个空的工程，随着本章课程的进展，我们需要不断地在工程中加入零星的代码，及时实践。

仍然是一个空的控件台程序。方法是……以前我们讲过，忘了就看前面章节吧。

代码文件Unit1.cpp中，手工加入以下的黑体部分：

//---------------------------------------------------------------------------

#include

#pragma hdrstop

//---------------------------------------------------------------------------

#pragma argsused

int main(int argc, char* argv[])]

{

getchar();

return 0;

}

//---------------------------------------------------------------------------

5.1.2 定义变量

语法：

数据类型变量名;

“张三”既可以指张三这个人，也可以是张三的名字。同样，上面的“变量名”，其实也就是变量本身。

举上一节的例子：

int age;

其中，int 是数据类型（整型），而 age 是变量名，更多的时候，我们就说是变量 age。最后是一人分号。它表示定义一变量在C或C++里一句完整的语句。因为C++的语言总是以分号结束。

如果要声明一个字符类型变量：

char letter;

声明一个bool类型的变量：

bool do_u_love_me;

其它类型，除了void不能直接定义一个变量以外，格式都是一样的。

void avoid; //错！void 类型无法直接定义一个变量。

有时同一时候同一数据类型需要多个变量，此时可以分别定义，也可以一起定义：

int a;

int b;

int c;

下面采用一起定义，会更省事：

int a,b,c;

一起定义多个同类型变量的方法是：在不同变量之间以逗号（,）分隔，最后仍以分号（;）结束。

让我们来试试变量定义，另外，我们还要趁此机会，看看一个变量在仅仅进行定义之后，它的值会是什么。继续上一小节的代码。仍然是加入黑体部分，当然 // 及其后面的内容是注释，你可以不输入。......

int main(int argc, char* argv[])]

{

/////////////////定义变量//////////////////////////////////////////////////

//以下定义三个变量：a,b,c

int a;

double b,c;

//a，b，c仅仅被定义，它的值会是什么？我们用 cout 输出三个变量：

cout << "a = " << a << " b = " << b << " c = " << c << endl;

getchar();

return 0;

}

最好先保存代码文件和工程文件。然后按F9运行。以下是笔者机器得到结果。

a 是1，b和c都像天文数字？嗯，从这里我们学到一个C，C++编程极其重要知识：未初始化的变量，它的值将是未确定的。所谓“未初始化”，就是指这个变量只有定义代码，而没有赋值。

（立即重复执行这段代码，得到结果可能都一样，但这并不说明这些值就是可以确定不变。）

5.1.3 如何为变量命名

C/C++的变量的名字中只能有以下字符：大小写字母、阿拉伯数字（但不能做为开头）、下划线 _。

汉字不能成为变量名。

不过，就算允许，又有谁会这么累呢，用汉字作变量名？

不能或不要

不能取名为C、C++的保留字。

如：

int char; //不行

这是不被允许的。char 是一个保留字。我们不能再拿来做变量。

不能超过250个字符。

这在BCB里有规定。是一个可以调整的值。

不能以数字开头

int 100; //不行

int 100ren; //不行

不能夹有空格

bool do you love me; //不行

你可以用下划线代替空格：

bool do_you_love_me; //OK

不能在同一作用范围内有同名变量（仅C++）

比如：

int abc;

int abcd;

int abc; //不行

在C里，上面重复定义变量 abc是被允许的。

关于作用范围,我们以后会讲到。

不要和C、C++中已有的全局变量，函数，类型名取相同的名字。

double sin;

这不合适。因为C库为我们提供了计算正弦值的函数，名字就叫 sin;

不要太长。

是的，250个字符其实太长了。如果有个变量名长达30个字母，我看不仅你自已写得累，别人看着也会觉得是在读外国小说，主人公的名字太长，烦人。

不要太短

这个我们放到后面说。

以上几点中，凡标为“不能”，意味如果你违反了，你的程序便会在编译时出错。而“不要”则仅属建议内容。真要这么做，程序也没错。

另外，我们还建议要为每个变量取一个有意义的名字。比如 NumberOfStudents,这个变量一看就明白是为“学生的人数”定义的。而如果定义为 aaa,cc,之类，就容易混淆。当然，有一些约定成俗的用法，如字母i,j，等常用来作循环流程中的计数变量。再者，有意义的名字并不是指一定要把变量所要代表的意思用英文句子写出，一般可以用简写，如 NumOfStudent，它同样意义明了，但更简短。而且，如果我们英文一般，那么有时也可以使用拼音。这里就不举例了，因为笔者连拼音都很次。

前面说到取名不要太短，说的就是避免像 aaa，cc之类的图输入方便，但毫无意义，不可读的变量命名习惯。

(你很快就会在教程中发现，笔者似乎自已违反了这个规定，用一些a,b,c作为变量名。这不能说是笔者的错。因为会有些时候变量的意义并不重要)

最后，C,C++是区要大小写的语言，所以变量 Num 和变量 num 完全是两个变量。大家在定义，使用变量要注意到这一点。

关于变量的命名，我们不做实践。下面附加说说编程中命名的一些风格。

附：关于命名变量的几种风格。

较早以前，现在仍流行于UNIX、Linux编程界，程序员喜欢用全部小写的单词来命名变量，如果两个单词，比如my car，常用的命名方法有两种：my_car或myCar。my_car自然看起清楚，不过输入频繁地下划线是件累事(根据指法，下划线必须使用小指头按)。后一种方法被称为“驼峰表示法”，原因是大写字母看起来想凸起的驼峰。

之所以不使用MyCar,原因是C/C++允许程序自定义数据类型，所以有必要从一个名字上很快地区分它是变量或是数据类型。方法是让自定义的数据类型都用大写开头。比如前面的说的“马”是程序员自定的数据类型，那么如果采用这里的命名规则，则应取名为：Horse，而“一匹白马”是变量，所以取名为：aWhiteHorse。

Horse aWhiteHorse;

在C++ Builder里，并没有限制大家如何为变量取名。所以为了仍可以很明显的做到上述的区分，CB的方法是对用户

自定义的数据类型在前头加一个字母T（Type的首字母）。仍如 Horse,则改名为：THorse。前面我们写Windows版的hello world时，使用了一个Label控件，其实，检查代码你会发现，它的类名就叫：TLabel。

最后还有一种方法是匈牙利标记法（Hungarian notation）。该法要求在每人变量的前面加上若干个用于表示该变量的数据类型的小写字母。如iMyCar表示这个变量是整型(i表示int);而倘若是cMyCar，则表示这个变量是char类型。该法经过一段时间的训练熟悉以后，会带来一些好处。问题是如果对自定义的数据类型也按这种方法进行，就不是经过训练就能熟悉了。比如hoWhite,这个名字中的ho表示“马”，真有点强人所难。举上实际存在的例子，在Windows API中，如果你看到：

LPCITEMIDLIST pidlRoot;

想要一眼看明白 pidRoot,必须的要求是你很明白 ITEMIDLIST 是什么玩意儿了。

是的，Windows的API使用的是最后一种方法。在大多数情况下，它的变量的名字都看上去怪怪的。

在本部教程中，我们在正式程序中，最常使用的方法是简单的“驼峰”法。

5.1.4 如何初始化变量

5.1.4.1 什么时候需要给变量初始化？

int a;

声明了一个整型变量a。但这变量的值是多少？a等于0吗？还是等于100？我们都不知道。“不知道”的意思是：a 有值，但这个值的大小是随机的，所以我们无法确定。

无法确定一个变量值是常有的事，比如我们要求用户输入他的年龄。我们需要声明一个整型变量来存储用户年龄，但在用户输入之前，我们是无法确认它的值。

但有些时候，我们可以事先给一个变量初始时的值。同样是年龄的问题，虽然我们不知道用户到底几岁，但我们知道他不可能是 0 ，所以我们把年龄一开始设为0。为什么要这样？用户有时不小心忘了输入年龄（就像我们在网上填表一样），我们就可以检查年龄是否为0来发现了。另外一种相反的用法是，我们发现大都数用户是8岁（比如一个小学生入学登记表），这时我们初始化年龄变量为8，目的是为了方便用户了。

那么，如果为一个变量赋值呢？

答案就像我们初中的代数：设 x = 10, y = 100。用等号。请记住：现实生活中，等号（=）有两个意义，但在C/C++里，＝只用来给一个变量赋值。

5.1.4.2 初始化变量的两个时机

1.在定义时初始化变量

int a = 0;

通过一个等号，我们让a的值等于0；

同时定义多个变量时也一样：

int a = 0, b= 1;

当然也可以根据需要，只给部分变量初始化。

int a = 0, b;

或：

int a,b = 1;

2.在定义以后赋值

int a;

a = 100;

5.1.4.3 通过计算得到初始值

给变量赋值，除了给一个直接的值以外，还可以通过计算获得。如：int a = -3 + 200 - 5;

或者如：

int a = 9;

int b = 3;

int c = a / b;

(/ 表示除号)

现在来试试给变量赋值的几种方法。

......

int main(int argc, char* argv[])]

{

/////////////////定义变量////////////////////////////////////////////////// //以下定义三个变量：a,b,c

int a;

double b,c;

//用 cout 输出三个变量：

cout << "a = " << a << " b = " << b << " c = " << c << endl;

/////////////////初始化变量//////////////////////////////////////////////// int d = 0;

float e = 1.234, f;

f = 567.8 + 0.2;

cout << "d = " << d << " e = " << e << " f = " << f << endl;

getchar();

return 0;

}

5.1.4.4 变量的取值范围

1). 变量允许取值范围＝变量数据类型的范围

关于赋值的最后一个需要注意的是：变量的取值范围。

变量的取值范围？变量是有类型的，变量的允许的取值范围等同于其数据类型的范围。比如一个整型数，那么它的取值范围就是：-2147483648 ~ 2147483647。而如果是一个字符类型，它的取值就不能是 -129。

以下是示例：

int a = 3000000000; //错误！

char b = -129; //错误！

我们来写代码实践一下。由于char类型计算机在输出将直接输出字符，我们不好观察结果，所以我们选择了int类型。

......

int main(int argc, char* argv[])]

{

/////////////////定义变量//////////////////////////////////////////////////

//以下定义三个变量：a,b,c

int a;

double b,c;

//用 cout 输出三个变量：

cout << "a = " << a << " b = " << b << " c = " << c << endl;

/////////////////初始化变量////////////////////////////////////////////////

int d = 0;

float e = 1.234, f;

f = 567.8+ 0.2;

cout << "d = " << d << " e = " << e << " f = " << f << endl;

/////////////////变量值越界//////////////////////////////////////////////////

int g = 3000000000; //给g赋值超过int允许的范围，所以g的值不可能如愿等于3000000000

cout << "g = " << g <

getchar();

return 0;

}

g 的值已经溢出，它的值究竟是多少？自已按F9运行，看结果吧。

2). bool 类型的特殊

至于 bool 类型，事实上它的内存空间范围和char一样是一字节的（因为计算机能直接处理的最小内存单位是字节），所以按说它也能存256个不同的值，但作为C++的一个规定，强制给它两个值: false,true。那么 false 是什么呢？其实它是0。而 true则是非0的数。也就是说，值0对应为false,而所有非0的数对应成true。

所以，你这样给bool类型的变量赋值自然没错：

bool do_u_love_me = false; //噢，你不爱我。

或

bool do_u_love_me = true;

但你也可以这样给来：

bool do_u_love_me = 0;

或

bool do_u_love_me = 1;

当然，我们建议使用第一种方法，那是“正规”的方法。

在C里，并没有bool这个数据类型，所以C程序员采用的方法是自定义：

typedef char BOOL;

如果你在某些书上碰到BOOL，你就可以明白它就是我们学的 bool.

false和true到底是什么？“假”或“真”，很简单啊。噢，我不是问二者的意思，C++之所以要加入bool类型，目的也是为了让程序员在处理那些只用于表示“真或假”、“是或否”等数据时，可以用直观的false和true来表示。而在计

算机内部，二者仍然是数。让我们写几行代码，揭开bool类型的“假面”。

......

int main(int argc, char* argv[])]

{

/////////////////定义变量//////////////////////////////////////////////////

//以下定义三个变量：a,b,c

int a;

double b,c;

//用 cout 输出三个变量：

cout << "a = " << a << " b = " << b << " c = " << c << endl;

/////////////////初始化变量////////////////////////////////////////////////

int d = 0;

float e = 1.234, f;

f = 567.8 + 0.2;

cout << "d = " << d << " e = " << e << " f = " << f << endl;

/////////////////变量值越界//////////////////////////////////////////////////

int g = 3000000000; //给g赋值超过int允许的范围，所以g的值不可能如愿等于3000000000 cout << "g = " << g <

/////////////////bool类型的"真面目"//////////////////////////////////////////

bool h = false ,i = true;

cout << "h = " << h << " i = " << i << endl;

getchar();

return 0;

}

运行后……原来，false是0，true是1。

3). char 类型的特殊

char 的范围是 -128 ~ 127

unsigned char 的范围是 0 ~ 255

那么按照前面的说法，我们可以为这样为一个字符类型的变量赋值：

char c = 120;

unsigned char uc = 250;

这样看来，所谓的“字符”类型，似乎除了取值范围小一点以外，和整型也没有什么区别。这句话的确没错。对于C、C++来说，字符类型完全可以当成一个整数来对待。

事实上，所有信息在计算机里，都是使用数字来表达。英文字母 'A' 在计算机里表示为 65; 字母 'B' 表示为66。所有你在键盘可以看到的字符，如大小写英文字母，阿拉伯数字符号，标点符号都可以有一个相应的数值表示。

但要让我们记住65就是'A',而33就 '!'等255个对应关系，显然很折磨人，所以，计算机高级语言允许我们直接为字符类型变量这样赋值：

char c = 'A';

char d = '!'; //英文感叹号

char e = '.'; //英文句号

char f = ' '; //空格

即：将所要得到的字符用单引号括住。（引号''是英文状态下的，千万不要使用中文符号）

另外，对于一个数值类型，如果它等于120，那么输出时显示的120，如果是一个字符类型，输出却是120对应的字符。也就是说：

int k = 120;

char j = 120;

二者虽然值都为120，但输出j时，计算机并不显示120这个值，而是120对应的字符。试试看！

为了不让教程中的代码重复占用版面，省略号省略掉的代码要多点了……

......

/////////////////char 类型///////////////////////////////////////////////////

int k = 120;

char j = 120;

cout << "k(int) = " << k << " j(char) = " << j << endl;

getchar();

......

输出结果，k当然是120，但j，原来120对应的字母是 'x'。写的是120，输出的却是x，很不直观对不？所以，除非我们故意要和自已或者其他看代码的人玩“密码”，否则，还是直接想要什么字符，就写哪个字符吧。

/////////////////char 类型///////////////////////////////////////////////////

int k = 120;

char j = 120;

cout << "k(int) = " << k << " j(char) = " << j << endl;

char l = 'A';

char m = l + 1;

cout << "l = " << l << " m = " << m << endl;

getchar();

......

输出结果，l为 'A',而 m 为 'B',想一想，为什么？学完后面内容就有答案。

单引号本身也是一个字符，如何表示单引号呢？是否用 ''' 来表示？看明白下面的常用字符ASCII码表以后再说。

（ASCII是指：American Standard Code for Information Interchange，美国信息交换标准码。）

(其中，0~31都是一些不可见的字符，所以这里只列出值为0的字符，值为0的字符称为空字符，输出该字符时，计算机不会有任何反应。我们以后会学习0字符的特殊作用。)

4). 转义符的使用

根据前面的说法，单引号应该表达为：

char c = ''';

但这是错误的。C、C++不认识 '''，因为它容易引起歧义。

另外，有一些字符属于不可见的字符，无法直接写出，比如键盘上大大的回车键，在输入文档时，用它可以输入一个回车换行，显然我们不能这样在C/C++里表示一个回车换行：

char c = '

'

在第一个'和第二个'之间夹了一个换行，这样的表示方法不仅不方便，C和C++也不认。

类似这样的问题还有制表符（键盘上的Tab键）等等。

解决的方法是使用转义符.C/C++使用反斜杠'\'作为转义符。如：

'\'' : 表示单引号；

'\"' : 表示双引号；

'\n' : 表示换行（n : line)；

下面列出常用的C、C++特殊字符：

这里顺便解释一下“回车换行”是什么，尽管我们对这个词耳熟得很。

“回车换行”是“回车”加“换行”。

换行好理解，但什么叫“回车”呢？它和“换行”又有什么关系？

原来，“回车换行”的概念源于早先的打字机。类似于现在打印机中有一个打印头，这个打印头平常停在打印机内的某一端。在打印一行时，则需要向外移动，打印一行结束后，打印头需要回到原来位置。由于打印头在英文中用“车”来表示，所以这个动作就称为“回车”，用金山词霸的中的解释就是：“将打印或显示位置移到同行起始位置的运动。”

所以对于打印机，假设有两行字，两行之间若光有“回车”，那么这两行字将重叠在一起(对于控制台程序的屏幕，则将回到行首)。如果光有“换行”，则第二行将不从起始位置打起，样子如下：

这是第一行

这是第二行。

只有既输出“回车”又输出“换行”，才是我们常见的换行结果。当然，对于当今的大都软件，往往都把单独的回车或换行直接解释于二者的结合。

转义符的另外一种用法是直接接数值。但必须采用8进制或16进制。这里暂不讲解。

如果需要使用数值表示，最直接的还是使用类似： c = 120; 的方法。比如要让变量c的值为单引号，我们至少可以有以下2种方法：

char c = '\''; //使用转义符

char c = 39; //直接赋给字符的ASCII的值。

转义符的内容，看上去怪怪的？不过，多用几次我们就会明白。

/////////////////char 类型///////////////////////////////////////////////////

int k = 120;

char j = 120;

cout << "k(int) = " << k << " j(char) = " << j << endl;

char l = 'A';

char m = l + 1;

cout << "l = " << l << " m = " << m << endl;

/////////////////转义符//////////////////////////////////////////////////////

cout << "TAB:" << '\t' << "AA" << endl;

cout << "换行:" << '\n' << "AA" << endl;

cout << "回车:" << '\r' << "AA" << endl;

cout << "听到BEEP声了吗？" << '\a' << endl;

cout << '\'' << endl;

cout << '\"' << endl;

cout << '\\' << endl;

getchar();

......

在执行之前，有必要稍作解释。

首先那是“AA"做什么用。因为制表符、回车、换行等特殊字符，其输出效果是改变光标位置，所以我们需要一些上下文来显示出光标位置改变效果，这里就随便写个“AA”了事。

然后是在cout语句中，平常我们叫是使用双引号输出一行话，但如果当前要输出只是一个字符，我们也可以使用单引号。

至于所谓“BEEP”声，你可别抱太多期望，它只是计算机内置的小喇叭短促一个声音，听起来并不美妙。

现在来看结果(请只关心转义符部分)：

关于输出结果的几点说明：

1、需要注意的是 '\t' 在控制台窗口的输出效果，如果前面的字符长度已超过一个制表位，那么后面的第一个'\t'将是没有效用的。（要理解这一点，你可以将代码中“TAB”加长一点，如"TABTAB"）。

2、“AA车”的输出结果是怎么来的呢？请大家考虑考虑。

试验程序在这里结束。

5.2 变量与内存地址

前面讲到“白马、黑马”时，我们说一匹白马和一匹黑马具有共同的数据类型

“马”，但二者是相对独立的个体。现在我们以共熟悉的“人”来继续这个话题，

最终引出变量与内存地址的关系。

张三和李四的数据类型都是“人类”。但张三和李四显然是独立的量：张三吃

了两块蛋糕，李四不可能因此就觉和肚子饱了；而李四在下班的路上捡到一个钱

包，虽然正好是张三的，两人似乎通过钱包有了点关系，但谁得谁失仍然不容混淆。

这一切都很好理解。张三和李四之所以是不同的个体，根本原因在于两人有着不同的肉身。如果是一对连体婴儿，虽然也是两个人，但当左边的婴儿被蚊子咬一口时，右边婴儿是否也会觉得痒，就不好说了。

现在我们困难的是，如何理解两个不同的变量，也是互相独立的呢？

答案就在“内存地址”，“内存地址”就是变量的肉身。不同的变量，拥有不同的内存地址。譬如：

char a;

char b;

上面有两个字符类型的变量a和b，a拥有自已的内存地址，b也拥有自已的内存地址，二者绝不相同。而a、b只不过分别是那两个内存地址的“名字”，恰如“张三、李四”。

让我们看图解：

看，内存就像是开宾馆的。不过这有宾馆有点怪。首先它每一个“房间”的大小都是一个字节(因此，计算机能单独处理的最小内存单位为字节)。它的门牌号也不叫房号，而是叫内存地址。

在左图中，“房客”，变量a住在内存地址为1000002的内存中，而变量b则住在它的隔壁，地址为100003的内存中。另外，如果你足够细心，你还会发现:内存地址由下往上,从小到大排列。