• 3.1 标识符• 标识符（ identifier ）在程序中可以作为不同

类型数据或函数的名字。常见的有：变量（ variable ）、结构（ struct ）、联合（ union ）、枚举（ enum ）、函数（ function ）、类（ class ）和对象（ object ）等。

• C++ 标识符由大、小写字母、数字和下划线组成，并只能以字母或下划线开始。

3 C++ 语言基础

• 在 C++ 中，并非所有的标识符都能作变量。系统所保留的关键字（ keyword ）在编译程序中有特殊的含义，不能用作变量名。这些关键字除了 C 语言原有的，如： asm ，auto ， bool ， break ， case ， char ， default ， do ， extern ， false ， float ， goto ， if ， int ， long ， true ， while 等之外，还有 C++ 增添的，如： class ， catch ， delete ，friend ， public ， new ， private ， protected ， virtual ， template 等。

• 3.2 数据类型

图 3.1 C++ 的数据类型

• 3.2.1 基本数据类型• C++ 语言的基本数据类型包括字符型（ char ）、

整型（ integer ）、浮点型（ float ）、 void 类型 和枚举类型。• 3.2.2 构造数据类型• 1 ）类型定义（ typedef ）• 关键字 typedef 用于定义一个标识符，表示一种数

据类型，经过定义的标识符可以像基本数据类型一样用在以后的变量说明和类型定义中。如：

typedef int Integer ； // 将标识符 Integer 定义为 int Integer x ； // 将 x 声明为 Integer 型，也就是整型 i

nt

• 2 ）结构体（ struct ）• 结构体是由同一名字引用的变量的集合，

集合中的每个元素称为数据成员（或称结构元素），每个元素使用名字来引用。结构体提供了将相关的数据汇集在一起的方法，使程序可以方便地处理像日期和学生信息这样的复杂数据。一经定义，结构体也可以用来声明变量，结构体声明变量的方法和普通数据类型相同。结构体的语法格式为：

Struct 标识符 {

数据类型 1 数据成员 1 ；

数据类型 2 数据成员 2 ； 数据类型 n 数据成员 n ； } ； 如： struct date{ int year; int month; int day; }; date my_date; my_date.year ＝ 1980 ；

• 3 ）共用体（ union ）• 共用体（或称联合类型）可以是不同类型

的数据共享同一内存资源，它的定义方式和结构类型非常相似，但实质差别却很大。与结构体相比，结构体把不同的数据集合在一起，一个结构体变量拥有多个数据；而共用体每次只能包含一种数据类型的信息，变量中始终只有一个数据。从内存占有情况来说，结构体变量所占内存长度是各成员所占内存长度之和，每个成员分别占有自己的内存单元；而共用体变量

所占的内存长度等于最长的成员的长度。其语法格式为：

union 标识符 { 数据类型 1 数据成员 1 ； 数据类型 2 数据成员 2 ； 数据类型 n 数据成员 n ； } ； 如： union data{ int i; char ch;

｝ u1;

u1 ＝ 1 ； u1 ＝‘ A’;

• 3.2.3 数据类型转换• 1 ）自动数据类型转换• C++ 的自动类型转换总是把较低优先级的

数据类型转换为较高优先级的数据类型。各种数据类型的优先级是由低到高的，顺序是： double ， float ， long ， int 和 short 。

• 2 ）强制类型转换

• C++ 提供的强制类型转换语法格式为： • 类型名（表达式）或（类型名）表达式

• 3.3 数组、字符串和指针• 3.3.1 数组• 数组变量（简称数组）是一组相同类型的

变量的集合。它用一个统一的名称来表示。其中，每个变量称为数组的元素变量，简称数组元素。数组分一维数组和多维数组，下标的个数称作数组的维数。在 C++ 中，数组是复合数据类型，其元素可以是除 void 类型和函数外的任何一种数据类型。

• 1 ）一维数组• 一维数组只有一个下标，定义一维数组的格

式如下： 数据类型数组名 [ 常量表达式 ] ；• 其中，数据类型是数组元素的类型，常量表

达式的值 n 即为数组元素的长度（元素个数）。数组的各元素在内存中连续存放，用数组下标来访问数组元素，第一个元素的下标值为 0 ，最后一个元素的下标值为 n-1 。

• 关于数组的定义要注意以下几点：

• ① 数组的命名和变量命名相同，遵循标识符命名规则。

• ②C++ 规定，数组下标只能用方括号表示。• ③C++ 的数组下标范围是 0 ～（ n-1 ），

不能越界，否则出错。• ④ 常量表达式中只能包括常量和符号常量，

不能包括变量。下面的定义方式是错误的： int n ＝ 10;

int a [n];

• 2 ）多维数组• 多维数组是数组的数组，即数组元素也是

数组。多维数组的定义形式为：• 数据类型 数组名 [ 常量表达式 1][ 常量表达

式 2]…[ 常量表达式 n] ；• 以二维数组为例，说明给多维数组初始化

的方法。• ① 将数组的初始值写在一对大括号内，按

照数组元素的存放次序依次向数组元素赋初值。数组元素的存放次序是按行存放，即先存放第 1行的元素，再存放第 2行的元素等，同一行内，按列的下标由小到大存放。例如：

int array[2] [3] ＝ {0 ， 1 ， 2 ， 3 ， 4 ，5}

• 执行完该语句后，数组元素的值为： array[0] [0] ＝ 0, array[0] [1] ＝ 1,

array[0] [2] ＝ 2, array[1] [0] ＝ 3,

array[1] [1] ＝ 4, array[1] [2] ＝ 5

• 另外，初始值的个数也可以小于数组元素的个数，那么剩余的数组元素的值将被取默认值 0 。若

int array[2] [3] ＝ {0 ， 1 ， 2}

• 执行完该语句后，数组元素的值为：

array[0] [0] ＝ 0, array[0] [1] ＝ 1, array[0] [2] ＝ 2, array[1] [0] ＝ 0, array[1] [1] ＝ 0, array[1] [2] ＝ 0• ② 按行给二维数组赋初值，例如： int array[2] [3] ＝ {｛ 0 ， 1 ， 2 ｝ ,｛ 3 ， 4 ，

5 ｝ }• 执行完该语句后，数组元素的值与第一次赋值

结果相同。• 3.3.2 字符串• 在 C++ 中，字符串实际上是一个字符数组，

它和普通字符数组不同之处在于，它一般作为整体来引用。在 C++ 中，没有专门提供字

• 符串类型，而是将字符串存放在字符数组中来使用。字符串的末尾字符一定是′ \0′ 。

• 3.3.3 指针• 1 ）指针的概念• 一个变量的地址称为该变量的“指针”。指

针是 C++ 对内存地址的一种抽象。指针变量是一种存放内存地址的变量，在 C++ 中指针的值就是地址。指针的一般定义形式为：

数据类型 * 变量名• 其中的数据类型可以是 C++ 中的任何一种数

据类型， * 是“指向”的意思。例如： int *p1,*p2;

• 该语句定义了两个指针变量： p1 ， p2 它们都是指向整型变量的指针变量。

• 在学习指针变量的引用之前，必须先熟悉以下两个重要的与指针相关的运算符：

• & 取地址运算符。• * 指针运算符（或称“间接访问”运算符）。• 例如： & a 为变量 a 的地址， *p 为指针变

量 p 所指向的变量。• 关于指针变量的引用，要注意以下几点：• ① 指针变量只能存放地址（指针），不能

将一个整型变量（或任何其他非地址类型的数据）赋给一个指针变量。

• ② 指针变量的值如果为 0 ，则称这个指针变量为空指针。空指针不指向任何变量，它的值在头文件中定义为 NULL 。一个指针变量说明为空指针，表明不指向任何变量，而指针变量不赋值是说明该指针变量的值尚不确定，需要在后面指定。

• ③ 指针变量表示的是所指向变量的首地址。例如，用字符型指针变量表示字符串时，是把字符串的首地址（即第一个字符的地址）赋给指针变量。

• 一般来说，指针所允许的运算有如下 4 种：

• ① 赋值运算：可以将一个指针所指向的变量的地址值赋给它，也可以将一个数组的地址值或者一个函数在内存中的入口地址值赋给所对应的指针，还可以将一个已被赋值的指针赋给另外一个相同类型的指针。例如：

int a,*p1,*p2; p1 ＝ &a ； p2 ＝ p1 ； // 使 p2 指向指针 p1 所指向的变

量， 即 p2 和 p1 都是指向变量 a 的指针• ② 一个指针可以加上或减去一个整数值，

包括加 1 或减 1运算。

• ③ 在一定条件下，两个指针可以相减。例如，指向同一个数组的不同元素的两个指针可以相减，其差便是这两个指针之间相隔元素的个数。

• ④ 在一定条件下，两个指针可以相比较。例如，指向同一个数组元素的两个指针可以比较，当这两个指针相等时，说明这两个指针是指向同一个数组元素的。

• 与指针变量密切相关的两个常用运算符，它们是内存地址的动态申请和释放。同 C相比， C++ 提供了性能更好的运算符 new和 delete ，用于实现内存的动态申请和释放。使用的基本格式为：

ptr1=new type; //ptr1 指向一个 type 类型 的变量 ptr2=new type[n]; //ptr2 指向一个 n 元 type

类 型的数组 delete ptr1; //释放由 ptr1 指向的变量 空间 delete [ ]ptr2; //释放由 ptr2 指向的数组 空间• 其中， p 为指针， type 为类型名。

• new 和 delete 这两个运算符的优点主要表现在：

• ① 不需要强制类型转换。• ②运算符 new 可以通过参数给内存赋初值，

但不能给数组空间赋初值。• 2 ）数组的指针和指向数组的指针变量• 一个变量有地址，一个数组包含若干个元

素，每个数组元素都在内存中占用存储单元，它们都有相应的地址。指针变量既可以指向变量，也可以指向数组和数组元素（把数组起始地址或某一元素的地址放到一个指针变量中）。所谓数组的指针就是指数组的起始地址，数组元素的指针就是数组元素的地址。

• 数组的指针变量的定义与指向变量的指针变量相同。例如 :

int a[10];

int *p;

p=&a[0];

• 表示把 a[0] 元素的地址赋给指针变量 p 。此时， p 指向 a 数组的第 0 号元素。 C++规定数组名代表数组的首地址，也就是第一个元素的地址。那么，也可以这样赋值 :

p=a;

• 注意 : 数组 a 不代表整个数组，上述语句仅把 a 数组的首地址赋给指针变量 p ，而不是把数组 a 各元素的值赋给 p 。

• 引用数组元素可以用下标法（如 a[3] ），也可以用指针法，即通过指向数组元素的指针找到所需的元素。 C++ 规定 p+1 指向数组的下一个元素，而不是简单地将 p 值加 1 。

• 如果 p 的初值为 &a[0] ，则：• ①p+i 和 a+i 就是 a[i] 的地址，即它们都指向

a 数组的第 i 个元素。• ②* （ p+i ）或 * （ a+i ）是 p+i 或 a+i 所指

向的数组元素，即 a[i] 。

• ③ 指向数组的指针变量也可以带下标，如p [i] 与 * （ p+i ）等价。

• 3 ）指针数组和指向指针的指针• 一个数组其元素均为指针类型数据，称为

指针数组，也就是说，指针数组中的每一个元素都是指针变量。指针数组的定义形式为 :

• 类型标识 * 数组名〔数组长度说明〕；• 例如： int *p[4];

• 指向指针数据的指针变量，简称为指向指针的指针。指向指针的指针的定义形式为 :

• 类型标识 **变量名；

• 例如： char **p;

• 3.4 运算符

• 3.5 控制结构• C++ 的流程控制语句主要是表达式语句、选择语句、循环语句和辅助流程控制的转向语句。

• 3.5.1 表达式语句、空语句和块语句• 在 C++ 中，大多数语句是表达式语句。在

一个表达式后面加上分号，就形成一个表达式语句。例如：

int x;• 空语句仅包含一个分号。空语句常用于程

序中某处语法要求起码要有一条语句，但实际上又没有操作可执行的情况，常见于 for 循环语句中。

• 块语句是以“ {” 开始，并以“ }” 结束，其间封装着一个语句序列。组成语句序列的语句可以是单语句、块语句或空语句。例如：

{ p_temp ＝ p0; p0 ＝ p1; p1 ＝ p_temp; }• 除块语句和空语句之外的其他语句称为单语句。块语句主要是为了满足将几条语句作为一条语句使用的要求。块语句在语法上等价于一条单语句，可以用在单语句可以使用的地方。注意：在结束一个块语句的右花括号之后不能加分号。

• 3.5.2 选择语句• 1 ） if 语句• if 语句的一般形式如下：• if （表达式） { 语句 1; 语句 n; }• 其中，表达式必须用圆括号（ ）括起来。• 花括号中的语句称为 if 语句的子语句，当

表达式的值为真时，执行子语句；否则跳过子语句执行后面的语句。当子语句只有一条时，花括号 { } 可以被省略。

• 这种形式的 if 语句的流程图如图 3.5 （ a ）所示。

图 3.5 if 语句的流程图（ 1 ）

• 2 ） if...else 语句• if...else 语句可以根据不同的条件分别执行

不同的语句序列，其一般形式如下：• if （表达式） { 语句 1; 语句 m; } else { 语句 m+1; 语句 n; }

• 当表达式为真时，执行语句 1 到语句 m ；表达式为假时，执行语句 m+1 到语句 n 。同样，若 if...else 语句中的语句序列只有一条语句时，可以省略花括号 { } 。

• 这种形式的 if 语句的流程图如图 3.5 （ b ）所示。

• 当一个 if 语句用作另一个 if 语句的子语句时，这个 if 语句称作嵌套的 if 语句。使用嵌套 if语句可以进行多重判断，不过一定要小心，因为 else 总是与和它在同一块中最接近它的if 语句相匹配的。其一般形式如下：

if （表达式 1 ）语句 1;

else if （表达式 2 ）语句 2;

else if （表达式 3 ）语句 3;

else if （表达式 m ）语句 m;

else 语句 n

• 这种形式的 if 语句的流程图如图 3.6 所示。

图 3.6 if 语句的流程图（ 2 ）

• 3 ）条件运算符 ? ：• C++ 提供了一个三元运算符，称为条件运算符（ ? ：），它可以简化条件表达式的表达形式。其语法格式为：

表达式 ? 语句 1: 语句 2

• 在执行时，首先对表达式进行求值，如果表达式的值非 0 （真），则执行语句 1 ；否则执行语句 2 。例如：

max ＝（ a>b ） ?a:b;

• 上面的语句与下面的语句序列是等价的： if （ a>b ）

max ＝ a;

else

max ＝ b;

• 4 ） switch 语句• switch 语句是多分支的选择语句，用于将一

个表达式的值与某些常量进行连续测试，如果某一常量与表达式的值相匹配，则与之相应的语句便被执行。其语法格式是：

switch （表达式） ｛ case 常量 1 ：语句序列；

break ； case 常量 2 ：语句序列； break ；

Default ：语句序列； ｝• 3.5.3 循环语句• 1 ） for 语句• for 循环语句的一般格式为：• for （表达式 1 ；表达式 2 ；表达式 3 ）语句

• 其中，表达式 1 是初始表达式，一般是赋值语句，用于为循环的控制变量赋初值；表达式 2 是条件表达式，它决定退出循环的时间；表达式 3 是增量表达式，用于决定控制变量的变化方式。

• for 语句的执行次序是：进入 for 循环时，先对表达式 1求值，然后对表达式 2进行求值。如果其为假，则终止循环；如果表达式 2 为真，执行 for 循环体中的语句。随后对表达式 3求值，然后再次对表达式 2求值，由表达式 2 的值决定是否进行下次循环。在 for 循环中，表达式 1 是赋值语句，仅求值一次。

• C++ 中规定，初值表达式 1 中可以包括变量说明，说明的变量在这个循环语句中有效。例如：

for （ int i ＝ 1;i<=10;i++ ）• 在 for 语句中，表达式 1 、表达式 2 和表达

式 3 中任何一个都可以省略，但它们之间的分号不能省略。

• 特别注意的是，如果表达式 2被省略，而 for 语句中又没有某个转移语句时，会造成 for 语句的死循环。这在程序设计中是不允许的。

• for 语句的流程图如图 3.7 所示。

图 3.7 for 语句的流程图

• 2 ） while 语句• while 语句的一般形式为： while （表达式）语句• while 语句首先计算表达式的值，在其值为真时，执行循环体中的语句；而在其值为假时，终止循环的执行，程序接着执行循环体后的语句。

• 另外需要说明的是，对于 for 语句的一般形式：• for （表达式 1 ；表达式 2 ；表达式 3 ）语句• 可以用 while 循环语句来描述：

表达式 1 while （表达式 2 ） ｛ 语句； 表达式 3 ； ｝• while 语句的流程图如图 3.8 （ a ）所示。• 3 ） do...while 语句• do...while 语句的一般形式为： do 语句 while （表达式）；

• do...while 语句和 while 语句类似，只是对循环条件的检查是在循环的尾部进行的。 do...while 语句先执行循环体中的语句，然后对表达式求值，在表达式值为真的情况下重复执行循环体中的语句，而在其值为假时，终止循环的执行，程序接着执行循环体后的语句。特别注意，“ while （表达式）”后面的分号不要遗漏。

• do...while 语句的流程图如图 3.8 （ b ）所示。

图 3.8 while 和 do...while 语句的流程图

• 3.5.4 转移语句• 1 ） break 语句• break 语句有两个用途，一个是用于 switch

语句中，前面已作介绍；另一个是用在循环语句的循环体中，起到强制退出循环语句的作用。当在循环体中遇到 break 语句时，循环立即终止，程序跳过 break 语句后的其余循环体语句，从循环语句后的第一条语句继续执行。

• 2 ） continue 语句

• continue 语句和 break 语句有点相像，不过当程序在循环体中遇到 continue 语句时不会退出循环，而是跳过 continue 语句后的其他循环体语句，继续下一次循环。

• 3 ） goto 语句• goto 语句是无条件转移语句，它需要一个

标号，标号是一个标识符，它的命名规则与变量名相同。标号是 goto 语句转向的目标。 goto 语句的一般形式是：

goto 语句标号；• 其中的语句标号可以在 goto 语句之前，也

可以在其后。

• 由于 goto 语句会破坏程序的结构化，造成程序运行的混乱和不可预测的后果，原则上应该限制 goto 语句的大量使用。

• 3.6 函数• 1 ）函数的定义• 函数定义的一般格式为：• 函数类型 函数名（形式参数表）• 函数体• 其中的函数类型就是函数使用 return 语句返回值的类型，如果没有设置函数类型，系统会将其缺省设为整型。如果函数执行完毕后无需返回任何值，将函数类型设为 void 。

• 形式参数说明表（数据类型参数 1 ，数据类型参数 2 ， ... ）是以逗号分隔的变量类型和变量名表。例如：

int sum （ int x,int y,int z ） { return （ x+y+z ） ; }• 函数可以没有形式参数，但圆括号是必须

有的。函数体是函数功能的实现部分。• 另外 C++ 中，允许程序内含有多个名称相

同的函数，这就是函数重载。下面声明的 3个函数具有相同的函数名，但每个函数的自变量不同：

input （ int i ）； //输入一个整数； input （ float f ）； //输入一个浮点数； input （ char ch ）； //输入一个字符；• 2 ）函数的调用• 函数调用的一般形式为：• 函数名（实参表）；• 如果调用的是无参函数，“实参表”可以没有，但小括号不能省；如果“实参表”部分包含多个参数，则各参数间应该用逗号隔开。实参和形参的个数应一致，而且要按顺序对应起来。例如：

average ＝ sum （ a,b,c ） /3• 另外，在调用一个函数时需要注意以下 3

点：• ① 如果使用的是库函数，一般应在文件头

用 #include 命令将调用有关库函数时所需要用到的信息包含到调用文件中。

• ②被调用的函数必须是已经存在的函数。• ③ 使用用户自定义的函数，并且该函数与调用它的函数在同一个文件中，一般还应在主调函数前对被调用函数的返回值的类型声明。

• 声明的一般形式为：

• 类型标识符 被调函数的函数名（参数类型说明）；

• 程序 8 ： #include <iostream.h> int w=3; int fun （ int ） ; void main （） { int w=10; cout<<fun （ 5 ） *w<<endl; }

int fun （ int k ） {

if （ k==0 ） return w;

return （ fun （ k-1 ） *k ） ;

}

• 3 ）函数的参数• 调用函数时一般需要向被调函数传送一些参数，为了保证参数的正确传送， C++ 要求每个函数都应有原型，也就是说在定义它之前应对形参类型及个数加以声明。

• 4 ）主函数的参数• 有时在运行程序时需要把信息传送到程序

中，主函数 main （ ）通过参数可以接受这些信息。主函数有 3 个参数，它们分别是 argc ， argv 和 env 。 argc 和 argv 用于接受命令行参数， env 用于接受程序运行于其上的操作系统的环境参数。

• 3.7 类和对象• 3.7.1 类的定义• 类是对一组性质相同的对象的程序描述，

由概括了该组对象共同性质的数据和函数组成。类的具体实例就是类的对象。

• 在 C++ 中声明一个类的一般格式为：• Class 类名 {

public ： 公有数据和成员函数 protected ： 保护数据和成员函数 private ： 私有数据和成员函数 }

• 关键字 class 表明了一个类说明的开始，类中所有的内容要用大括号括起来，类中定义的数据（变量）和函数分别称为成员数据（变量）和成员函数。

• C+ + 的类成员分为 3 种级别的访问权限，它们分别用关键字 public,protected 和 private 来表示：

• Public （公有的）说明类的成员是公有的，它不仅可以被该类的成员函数访问，而且可以被外界访问。

• Private （私有的）说明类的成员是私有的，只能被该类的成员函数和友元函数访问，外界不能直接访问它。

• Protected （保护的）说明类的成员是被保护的，只能被该类的成员函数、友元函数和该类的派生类的成员函数访问。

• 一般来说，一个类中总是包括了一定数量的公有成员，没有公有成员的类由于没有提供任何接口，所以事实上没有任何用处。

• 注意 : 由于类也是数据类型，所以在类定义完成的右花括号后面必须有一个分号，表示语句的结束。

• 3.7.2 对象的定义• 类是一种用户自定义的数据类型。和其他

数据类型一样，要使用类，必须声明类的变量（即类中的对象）。对象声明有两种方式，一种在定义类时直接声明对象，另一种在声明类之后再在需要声明对象的地方作单独声明。

• 对象被声明后就可以使用。通过对象可以使用类中的公有类型的数据和函数，其使用方式为：

• 对象名 . 数据成员 或 对象名 . 成员函数• 其中的“ .”被称为成员选择运算符。

• 3.7.5 构造函数和析构函数• 1 ）构造函数• 构造函数的名称与类名称相同，它不能有返回值，甚至不能有 return 语句。简单地说，构造函数是一个特殊的成员函数，用于初始化类数据成员。

• 构造函数一般必须定义成 Public 型，否则，就会发生在声明一个类时无法调用构造函数的情况。但在某些特殊情况下，也可以将构造函数定义成 Protected 或 Private ，但建议不要这样做。

• 2 ）析构函数• 当一个类的对象完成使命，要从内存中清

除前，析构函数就会被自动调用，用来释放该对象所占用的资源。析构函数相当于反向构造函数，只是在构造函数的名称之前加上一个“～”符号。例如，类 location的构造函数是 location （ ），析构函数是～ location （ ）。

• 在类中定义析构函数的方法是：• class 类名 ｛ 类名（） // 构造函数的声明 ～类名（） //析构函数的声明

｝ // 构造函数的实现 类名：：类名（） ｛ ｝ //析构函数的实现 类名：：～类名（）

｛ ｝

• 析构函数可以是 Public 的，也可以是 Protected 或 Private 。无论析构函数有怎样的作用域其功能都是相同的。析构函数的实现部分和普通成员函数一样，可以放到程序的任何位置，但通常将它和类中的所有成员函数放在同一个源文件中。

• 析构函数同样不能指定返回类型，同时析构函数不能带有参数表，而且不可以重载。

• 3.7.6 类的友元• 1 ）类的友元函数

• 一个类的友元函数（简称为友元）是在该类中说明的一个函数，它不是该类的成员，但允许访问该类的所有对象的私有成员和保护成员。

• 把一个函数定义为一个类的友元的格式是： // 函数原型说明： 数据类型 函数名（参数表）； // 在类的定义中定义友元函数： class 类名 {

friend 数据类型函数名（参数表） ;

};

• 另外，一个类的成员函数也可以说明为另一个类的友元。

• 2 ）类的友元类• 除了可以将一个函数定义为一个类的友元

函数外，还可以将一个类定义为另一个类的友元类。如果一个类 A 是类 B 的友元类，则类 A 的所有成员函数在对类 B 的对象进行操作时，可以读写类 B 对象的所有数据成员，包括保护的和私有的数据成员。

• 将类 A 定义为类 B 的友元类的方法是：

class A

{

};

class B

{

friend class A;

};

• 3.8 继承• 3.8.1 类的继承• 类的继承就是创建一个具有别的类的属性

和行为的新类。即从已有的对象类型出发，建立一种新的对象类型，使它继承（具有）原对象的特点和功能。

• 新类继承了原始类的特性，新类称为原始类的派生类（子类），而原始类称为新类的基类（父类）。派生类可以从它的基类继承方法和实例变量，并且类可以修改或增加新的方法使之更适合特殊的需要。这

也体现了大自然中一般与特殊的关系。继承性很好地解决了软件的可重用性问题。

• C++ 中有两种继承：单一继承和多重继承。• 3.8.2 单一继承• 单一继承就是只通过一个基类产生派生类。

这个派生类的基类只有一个，它从基类继承所有成员。

• 单一继承的一般形式为： class派生类名：访问权限基类名 ｛ private ：

成员说明列表 public ： 成员说明列表 ｝； • 3.8.3 多重继承• 多重继承的派生类有多个基类。其一般形

式为：• class派生类名：访问权限基类名 1 ， ... ，

访问权限基类名 n { 成员说明列表 }

• 派生类继承了所有基类的数据成员和成员函数，访问权限用于限制其后的类中的成员在派生类中的访问权限，其规则和单一继承的情况一样。多重继承可以看作是单一继承的扩展。

• 3.9 多态性和虚函数• 多态性是指允许不同类的对象对同一消息做出响应。如同样的加法，把两个时间加在一起和把两个整数加在一起肯定完全不同。又如，同样的选择、编辑和粘贴操作，在文字处理程序和绘图程序中又有不同的效果。多态性语言具有灵活、抽象、

行为共享和代码共享的优势，很好地解决了应用程序的函数同名问题。

• C++支持两种多态性：编译时多态性和运行时多态性。编译时多态性通过使用重载函数获得；运行时多态性通过使用继承和虚函数来获得，下面介绍的就是这种多态性。

• 虚函数声明的一般形式为： virtual 数据类型 函数名（形式参数表）• 虚函数是为实现某种功能而假设的函数。它

只能是类中的一个成员函数，但不能是静态成员。当在派生类中定义了一个同名的成员函数时，只要该成员函数的参数类型及返回

类型与基类中同名的虚函数完全一样，那么无论是否用 virtual 关键字，它都将成为一个虚函数。即基类的虚函数定义影响其派生类，而派生类的虚函数定义不影响其基类。

• 3.10 重载• 3.10.1 函数重载• 函数的重载是 C++ 语言的重要特点之一。通

过函数重载，可以使两个具有不同功能的函数共享同一个函数名。简单地说，就是赋给同一个函数名多个含义。在 C++ 语言中，如果两个函数的函数名相同但参数表不同，这

两个函数就互为重载（ overloaded ）函数，意为一个函数名被使用两次（或以上）。函数的重载不仅可以发生在普通函数中，也可以发生在同一个类的不同成员函数间。

• 定义两个具有相同函数名，但具有不同参数表的函数，后一个函数就重载了前一个函数。使用函数重载主要是为了减轻程序员的记忆负担，增加程序的可读性。

• 函数重载的基本规则有如下两点：• ① 函数必须包含两个不同参数的自变量表。• ②两个函数自变量表中的自变量至少有一个

是不相同的。

• 对于 C++ 语言编译器来说，两个重载函数是两个完全不同的函数（尽管它们的名字相同）。所以，一个被重载的函数可以调用另一个与其同名的函数而互不干扰。程序运行时会自动根据参数类型的不同而调用不同的函数。

• 函数重载也可以用在类的成员函数中。在对类的成员函数进行重载时，还需注意以下几点：

• ① 不同类间同名的成员函数不是重载，这是因为它们具有不同的作用域。重载只发生在同一个类的不同成员函数间。

• ② 可以重载构造函数。

• ③ 如果一个构造函数有且仅有一个参数，则可以使用赋值号“＝”来声明一个新的对象。

• ④ 由于析构函数不能带任何参数，也就不可能重载析构函数。

• 3.10.2 运算符重载• 运算符重载是为 C++ 中已有的运算符赋予新的功能，但与该运算符原有的功能并不冲突。使用时只需根据运算符出现的位置和操作数的类型判断应该执行哪一种运算。事实上， C++已有的运算符中，很多已经是重载了的。例如 :“+”运算符，它可以对整型、浮点型、指针等变量作运算。

• 声明运算符重载函数的一般形式为： 函数类型 operatorθ （参数表）• 其中， operator 是用于定义运算符的关键字，

θ 表示欲定义的运算符，函数类型指明返回值的类型，通常与类类型一致或为 void 型。

• 在 C++ 中有 3 种通用的运算符：算术运算符、逻辑运算符和位运算符。可以将所有的 3 种运算符进行重载，让它们去完成程序员需要的动作而取代其默认情况下的操作。

• 注意： C++ 不允许重载以下的 5 种运算符：• 条件运算符（ ?: ）

• 成员运算符（ . ）• 成员指针运算符（ -> ）• 范围分辨符（ :: ）• Sizeof运算符

• 3.11 C++ 语言书写规范• ①C++ 程序书写格式自由，一行内可以写上几个语句，一个语句也可以写在多行上。C++ 程序没有行号，不像其他 FORTRAN或 COBOL 语言那样严格规定书写格式。

• ② 每个语句和数据定义的最后必须有一个分号。分号是 C++ 语句的必要组成部分。即使是程序中最后一个语句也应包含分号。尤其应当注意的是，空语句也不能少了分号。

• ③ C++ 语言本身没有输入输出语句。输入和输出的操作是由 cin 和 cout 等函数来完成的。而 cin 和 cout又包含在头文件 iostream.h 中。

• ④ 在 C++ 语言中，除了可以使用标准注释分隔符（ /* 和 */ ）外，还可以使用“ //” 来标识单行的注释行。

• ⑤在 C++ 语言中，局部变量的声明语句是个常规语句，可以放在语句能够出现的任何位置，只要在首次引用之前即可。