vc语法汇总

VC++语法知识汇总
第2章 运算符
基本成份 关键字：由小写字母组成；
标识符：运算对象名，由字母、数字和下划线组成，不能以数字开头、不能是关键字，大小写严格区分；
运算符：<<,+, = =等表示指定运算；
常量：具体的数据；
串：用双引号括起来的字符序列；
特殊符号：{,}, //, #, (, )等。

1．常量
整型：十进制；八进制（0开头，由0~7组成）；十六进制（0x开头，由0~9和A~F组成）实型：小数形式（由0~9和小数点组成）；指数形式（尾数e指数，尾数和指数必须有值，指数为整数）
字符型：单引号引起的单个字符或转义序列，转义序列由\开头，后跟对应字符的ACSII码（用八或十六进制数表示，默认为八进制数）或字符
标识符常量（符号常量）的定义方法：编译预处理指令 #define 标识符常量名 常量值 常量说明符 const 类型 标识符常量名=常量值；2．变量
变量在使用前，必须有值。

说明格式：[存储类型] 数据类型 变量名1[, 变量名2,?,变量名n]；

变量先说明后赋值：[存储类型] 数据类型 变量名；变量名=表达式；变量说明时直接赋初值：[存储类型] 数据类型 变量名=值；

操作数非0 为真、0 为假；运算结果真为1、假为1，且继续参加运算。

（3）逻辑运算符：!（非）、&&（与）、||（或）
运算规则：非真即假，&&运算时操作数中有一个为0(假)时为假，||运算时操作数全为0(假)时为假；括号优先，同层的优先顺序为!、&&、||，从左到右，一旦能确定结果值，停止运算。

（4）赋值运算符：=、+=、-=、*=、/=、%=等
左操作数必须为变量；先计算右操作数；i*=j+2等价于i=i*(j+2)
（5）自增自减运算符:++、--
操作数为变量，运算符的位置会影响两个值（前置：表达式为运算前的变量值，变量自增自减1；前置：变量自增自减1，表达式为运算后的变量值）
（6）逗号运算符：，
从左到右依次计算各操作数，最后一个操作数的值为表达式的值。

（7）条件运算符：？：
操作数1 的值为真（非0），表达式取操作数2的值，否则表达式取操作数3的值。优先级条件运算，逗号运算 ：一元运算（一个操作数），二元运算（算术运算、关系运算、逻辑运算，赋值运算），

1

4．类型转换
自动转换：一般表达式中向数据长度增加的方向转换；赋值表达式向左操作数类型转换。强制转换：（type）表达式或type（表达式）；只改变表达式的值的类型。

第1~3章 VC程序的结构
1．程序的基本结构
#include<iostream.h> //预处理部分
… //说明部分（全局变量说明部分、自定义函数说明），可以无
voidmain(void) //主函数说明
{
… //函数体，说明部分、操作部分（一般由输入、处理和输出三部分组成）}
程序中严格区分字母大小写；中文符号只能出现在字符串或注释中；采用缩格式。

2．输入
cin>>变量1>>变量2>>…>>变量n；
注意：变量类型可以是整型、实型和字符型；键盘输入的数据之间要用空格或回车隔开；数据的类型、顺序、个数与列举的变量对应一致；当接受到类型不致时，对应变量值为0，以后的输入数据丢失、变量无值；当个数不足时，等待继续输入；当个数超过时，取所需个数的数据，多余的由后面的输入接收或自动放弃；

3．处理各种语句（说明语句、表达式语句、流程控制语句、空语句、复合语句）的集合。
cin.get(字符型变量名)；
注意：每次从输入行中接受一个字符（包括空格和回车符）到指定变量中；

4．输出要将表达式用圆括号括起；当表达式为字符（串）常量时，输出引号里的内容，如果串中含
有转义字符时，输出对应的ASCII字符；连续输出的表达式的值，如果需要间隔，则必须人
为增加输出分隔符；也可以使用setw(整数)规定其后一个输出项的宽度，但要在预处理部
分加预处理指令#include<iomanip.h>。

第4章 流程控制语句

if(表达式){ 语句1；语句2； …

1．分支语句
（1）单分支语句if
1）if(表达式)
语句；

执行流程见图1。 图1 图2 }

注意：循环体可以是单一语句或复合语句（用{}括起），其中必须有改变表达式（循环条件）值的相关语句，且能最终使表达式（循环条件）为假。

（2）do-while语句
do
语句；
while (表达式);
执行流程见图5。

注意： 1）while后的;不能缺少。

2）while与do-while的区别：while的循环体可以不执行，而do-while的循环体至少执行1次；while先判断后执行，do-while先执行后判断。

（3）for语句
for(表达式1；表达式2；表达式3)
语句；
执行流程见图6。

注意：1）表达式1只执行一次，用于初始化循环控制变量。

2）表达式2在每次准备循环前执行，为循环控制条件。

3）表达式3在每次循环后执行，用于更新控制变量

成立，其他表达式省略，则为空。 图6的值。

4）各表达式均可省略，

（4）循环嵌套

第5章 函数
1．函数定义
类型 函数名（参数1，参数2，…）
{ 功能语句系列；
[ return (表达式）；]
}
注意：（1）参数的定义形式为：类型 形式变量名 （2）每个参数要分别定义，中间用“，”分隔。

（3）形式变量的使用范围为函数体内，不需要给初值，由函数调用时给定。 （4）函数名前的类型省略时，默认为整型。当函数名前的类型为非void时，函数体中至少要有一条return语句。

（5）return后表达式值的类型若与函数名前的类型不一致时，以函数名前的类型为准。

注意：（1）实际参数的个数、顺序、类型都是由形参决定，但实参使用的是已经存在的变量、常量或表达式。

（2）有返回值时，函数表达式可出现在一般表达式中。无返回值时，直接加“；”构成表达式语句。

函数的首部（3）当定义在调用后面时，在调用前必须进行函数说明，说明的格式为：
加“；”。其中的形式参数名可以省略。

（4）参数值的传递方式有：值传递、地址传递和引用传递。

值传递：实参将值单向传递给形参，函数中对形参的操作，在离开函数后，形参不复存 （即实参和形参各自占有空间，值的传递为单向）在，实参的值保持不变。

地址传递：实参向形参传递的为地址，函数中对形参地址中的内容操作，在离开函数后，该地址中的内容仍然存在。

引用传递：实参和形参共享空间（形参为实参的别名）
3．函数的嵌套调用：在调用一个函数的过程中，那个函数又调用另一个函数。

函数的递归：一个函数在调用的过程中直接或间接地调用了自己。

执行流程：从主函数进入，当遇到函数调用时，转向被调用的函数执行，执行结束后，返回到原调用点继续执行。

4．函数重载：定义多个同名函数，调用时，根据提供的实参个数或类型顺序决定所调用的函数。

注意：（1）定义重载函数的原则是重载的函数在参数上要与原函数有所区别，即参数个数不同，或参数的类型顺序不同。

5．函数的缺省参数注意：（1）如果函数定义在后，则在原型说明时给了缺省值后，函数的定义时就不可再给
（2）函数重载在编译时实现程序的静态多态性。

缺省值。

于参数的最右边。

6．内联函数
在函数定义的前面加inline
7．作用域
（1）块作用域 局部变量，同一个块内不允许两个标识符同名，但不同块中的两个标识符可同名。且内层的标识符屏蔽外层块的同名标识符。

（2）文件作用域全局变量，若有同名的局部标识符，则在同名局部标识符的作用域内缺省使用的是局部标识符，但仍可以通过作用域运算符“::”来使用具有文件作用域的同名标识符。

（3）函数作用域 语句标号，goto中使用；无“先说明后使用”的，也不无块的；作用范围在函数内部。

（4）函数原型作用域 作用范围在函数原型说明语句。

8．存储类型
（1）auto 局部变量，一旦离开作用域，该变量就不再存在。

（2）static局部静态变量：作用域为块作用域，在离开其作用域时，变量仍然存在，且其值不变，但暂

时不可使用，下一次函数调用时在其作用域内可以再次使用，其值延续以前的变量值。更重

5

要的是，对于静态局部变量，仅在首次遇到说明语句时为其分配存储空间并赋初值。一般用于用户自定义函数中。

全局静态变量：在说明全局变量时如果加上static，其变量仅在本程序文件中使用，在其它程序文件中不可使用。可以避免在多个文件组成的程序中变量的重名问题。

（3）register 使用CPU中的寄存器作为变量空间存放数据。

（4）extern 外部变量一定是全局变量，属于静态存储类型。

在同一源程序中定义的全局变量，属于先使用有两种情况必须使用外部变量，第一种情况：
后定义的，在使用之前要声明该变量为外部类型变量；第二种情况：与static全局变量相对应，当在一个源程序文件中要使用其它文件中说明的全局变量时，要用extern先对变量进行声明。

9．编译预处理
特点：1）以#开头标识。

2）每一条预处理指令各占一行，不是以分号结束。

3）在编译源程序之前进行。

（1）文件包含
格式为： #include "文件名"或#include <文件名>
注意：（1）文件名为文件名的全称，若非系统缺省目录，应指明文件路径。

系统缺省目录有两种：包含系统指定的专用包含文件目录中的文件“<>”指定。扩 ；当前目录（用户源程序所在的目录）下的文件用双引号指定。展名通常为“.h”

1）不带参数的宏 格式： #define 宏名 字符序列注意：①宏名(标识符)通常用大写字母表示，以区别于普通变量。 （2）一条包含命令只能包含一个文件。

（2）宏定义

2）带参数的宏 格式： #define 宏名（参数列表） 字符序列
注意：①参数列表中不能指定类型。

② 宏名与括号之间不能有空格。

③ 宏代换只是对参数作简单的替换而不做任何计算。

④宏定义通常在一行内定义完，并以换行符结束，不可与其它语句同行编写；当一个宏定义多于一行时，必须在换行前先输入一个转义符“\”。

（3）条件编译
#ifdef 宏名
程序段
# end if
10．程序的多文件组织
多文件组织的程序，可以通过三种方法实现：
（1）在含有主函数的文件中用#incude命令将不同的文件包含进来，再对含有主函数的文件进行编译处理。

（2）将各源程序单独编译成目标程序，然后作连接处理。（3）使用工程文件的方法，将各源程序文件都添加至一个工程项目中，由编译器自动处理。

程序的多文件组织，需遵守以下原则：

6

1）要使用其它文件定义的函数或变量，使用前要再以extern进行说明。

2）如有不想让其他程序文件使用的函数和变量，则用static修饰的函数或变量限于本源程序文件内使用。

第6章 数组
1．数组的定义
1）一维数组 数据类型 数组名[元素个数];
2）二维数组 数据类型 数组名[行数][列数];
注意：①元素个数（行数、列数）必须为一个大于零的整型常量，不可为有变量的表达式或变量。

② 数组必须先定义后使用，在使用前各元素必须有确定的值。

2．数组的初始化
数组元素的初始化方法：
（1）以集合形式给出所有元素的值。（二维，先行后列取值）
（2）以集合形式给出部分元素(不能多于元素个数)的值（二维以行为单位），其余元素的值则分别被赋0。

（3）可以在定义数组时不限定数组元素个数（二维只能不限定行数），而由给出的元素个数来确定数组的大小。

（4）如果定义的数组为全局类型或静态类型，则数组各元素有缺省的初值0（字符型数组 ）。元素缺省初值为’\0’

（1）数组元素的使用 一维 数组名[下标]
3．数组的使用
一般数组（非字符数组）是面向元素的，不可直接对数组名进行输入、处理和输出。

④ 数组元素作为函数实参时，为值传递方式。

（2）数组名的使用
注意：①数组名可以看作常量，值为存放数组元素的空间首地址，只能使用，其值不能被改变。

②一般用于函数的实参，为地址传递方式，对应的形参定义形式同数组定义（元素个数可以省略），
③作为函数的实参时，函数体中对数组操作时要注意下标不能越界。

4．字符数组
（1）定义：char 数组名[常量表达式]；
char 数组名[常量表达式1][常量表达式2]；
（2）字符数组的初始化 用字符串对字符数组初始化，可以不指定数组大小，通过字符串的大小确定数组的大小，但系统会给字符数组自动增加一个字符串结束标志’\0’。（3）字符数组的使用 可直接对数组名进行输入、处理和输出。

输入：cin>>数组名；或cin.getline(数组名，数组长度); 后一种方式可接收空格。

字符数组1的大小必须≥字符数组2的大小；字符数组2可以是数组名，也可以是字符串常量；
②strcmp（字符数组1，字符数组2） 逐个比较对应的字符的ASCII，全部相同，返回0；前面大，则返回1；前面小，则返回-1。

③strlen（字符串） 返回字符串从开始到第一个结束标志之间（不包括结束标志） 。的字符个数。sizeof(字符串)返回字符串所占字节数(包括结束标志）

第7章 结构体
数组中只能存放同类型的数据。

结构体变量中可以存放不同类型的数据。

1．结构体的定义
（1）先定义类型，再定义变量
struct stu{

char xh[10];

char xm[8];

float math,english;

};
stu st1[30],st2,st3;
（2）定义类型的同时，定义变量
struct stu1{
char xh[10]; char xm[8]; float math,english;

（3）不指定结构体类型名，说明类型的同时定义变量struct{ } st4[30],st5;
stu1 st6;

（2）结构体类型变量不能直接进行输入/输出，成员的直接输入/输出取决于其类型；
（3）结构体类型变量可以作为函数的参数（作输入参数，为值传递），函数也可返回结构体
值。

3．结构体类型变量成员的使用：结构体变量名.成员名
注意：1）成员的赋值可以在定义的同时进行，也可以先定义后赋值。

2）成员可进行操作与运算由成员的类型确定。

4．结构体数组：数组元素的类型为结构体
访问方式：数组名[下标].成员名

第8章 指针
1．指针变量的定义 类型*指针变量名；
注意：类型为指针变量的值（地址）相应空间中的数据类型
2．指针变量的使用
指针变量中存放的内容为内存空间的地址，一般变量所占内存空间的地址可以用取地址运

同类型变量之间相互赋值，如inti,*p=&i，*p1;p1=p;
（2）内存中的数据存取 1）直接存取 一般变量名直接访问
2）间接存取 通过指针变量访问 使用取内容运算符*
（3）指针变量的运算
常用于对数组的操作中
1）算术运算 +和-
指针加或减一个整数n表示指针指向当前内存中相邻的同类型的数据的后面第n个或前面第n个数。

两指针变量相减表示两地址之间的元素个数。

注意：两指针进行相加运算无意义。

2）关系运算 表示指针之间的位置关系
==与!= 表示两指针是否指向同一个内存单元。

>、>=、<、<= 表示两指针的前后位置。

3．指针与数组
（1）数组名为整个数组的首地址，可作为一个指针，是一个常量；指针变量的值是可以改变的。

（2）指针数组 类型 *数组名[元素个数]; 数组的元素为指针
（3）数组指针 类型 (*指针变量名)[元素个数]；指针指向指定元素个数的数组4．指针与函数

形参 (int *p,int a[],inti) 实参 (pr,b,n) (b,pr,n) (&n,b,n)
（1）指针作为函数的参数 属于地址传递
有定义：intn=10,b[10],*pr=b;

（3）指向函数的指针 返回值类型 (*指针变量名)（形参表）；
5．指向指针的指针 如 int *p1, **p2, ***p3;
6．引用
（1）引用的定义 int a, &b=a;
注意：1）一定要用一个已存在的变量初始化。

2）引用的类型和被引用的类型要一致。

3）可以引用数组中的元素，但不能定义引用类型的数组。

4）可以把某引用的地址赋给指针，该指针则指向被引用的变量。

5）可以定义引用的引用，也可以两个变量对同一个变量进行引用。

6）对动态内存引用时，不可引用其地址，只能引用其值。通过引用变量释放动态内存时要取其地址。

（2）引用的使用 一般用在函数的形参中，属于引用传递
有定义：intn=10; 形参：(int&i) 实参：(n)
在函数体中对形参所作的操作实际上就是对函数调用时的实参的操作，其实参的值将

注意：1）定义const型常量的同时必须对其初始化。

2）const型常量一经定义，就不能再对其进行赋值。

（2）const型指针
有定义：inta=5, b=6, c=7;
三种形式：
1）指针所指向的值不变 constint *p1=&a;
2）指针的值不变 int*const p2=&b;
3）指针以及指针所指向的值都不变 constint *const p3=&c;
8．new和delete运算符
char*p,*p1, *p2, (*p3)[10], *p4;
new 用于为指针变量申请指向的空间，返回空间的地址：
p=newchar; p1=newchar(‘A’); p2=new char [10];
p3=new char [5][10]; //或p3=(char (*)[10]) new char [5*10];
p4=new char [5*10]; // 或p4=(char *) new char [5][10];
delete释放new申请到的空间：
deletep; delete p1;delete [ ]p2; 或delete[10]p2;delete [ ]p3 或delete[5]p3;
9．链表
（1）链表结点结构为：

（2）链表的建立 1）先设立一个指针（head）来存放链表的首地址。指针head的初值赋为0。
struct node { 数据成员的定义;
node *next;

（3）链表结点插入
将结点p插入至一个结点p0 和结点p1之间的操作： p->next=p1；p0->next=p；
注意：顺序不能颠倒。

（4）链表结点删除
1）找到要删除的结点p;
2）有三种情况：
删除的结点是首结点(p==head)，则将第二个结点的首地址作为新的链首地址返回; head=p->next;
删除的结点是链尾(p->next==NULL)，则原最后第二个结点成为新的链尾。

p0->next=NULL;
其他：将要删除的结点的前一结点p0的next指针指向要删除结点的后一个结点p1(p->next)。p0->next=p->next;
说明：后两种情况处理操作相同，可以作为一种进行处理。

3）由于链表的结点利用的是动态内存，删除结点时要释放被删除结点的动态内存。

到head为NULL。

（6）链表遍历
从链首结点开始，逐个访问结点。p的初值为head，下一个结点为p=p->next。

注意：在链表操作中，只要用new申请的空间，一定要用delete进行释放。

11

第9章 面向对象
1．类与对象的概念
类：数据与处理这些数据的函数的封装体。可理解为用户定义的一种类型，系统不分配空间。

：类的一个实例，是动态产生和动态消亡的。可理解为具有类类型的变量，有存储空间。对象
对象对消息的处理是通过激活对象内相应的函数实现。

2．类的定义
class 类名{
private: 成员名表1； //定义私有成员 public: 成员名表2； //定义公有成员 protected: 成员名表3；//定义保护成员 }
注意：
（1）在类体中未明确指定成员的访问权限时，系统约定为私有成员。

（2）私有成员只允许在该类中的成员函数中使用；
公有成员不仅允许在该类中的成员函数中使用，还允许在类外通过“对象.成员”方式使用；
保护成员允许在该类的成员函数中使用，也允许在该类派生类的成员函数中使用，不允许在类外使用。

（3）在类定义中，可以仅给出成员函数的原型，但成员函数的定义必须在类体外给出定义。

（4）在类中的任何成员数据均不能使用关键字exert、auto或register 限定其存储类型。 { } //函数体
类体外定义一个类的成员函数的一般格式：
类型 类名：：函数名（参数表） //类型为函数返回值的类型

4．对象的说明与使用
（1）说明对象的方法：
1）先定义类的类型，再说明对象；
2）在定义类的同时说明对象；
3）直接说明对象，而不定义类的类型
在定义对象时，允许对公有成员数据进行初始化，但不允许对私有成员数据或保护成注意
：员数据进行初始化。

（2）对象的使用
1）成员的访问 公有成员：对象.成员；私有成员和保护成员只能通过对象的公用成员函数来获得。

2）同类型的对象之间可以整体赋值。

3）对象可以象一般变量使用，在作函数的参数时，属于赋值调用。

第10 章构造函数和析构函数
构造函数的作用析构函数的作用：在撤消对象前做结束工作，即收回对象所占用的存储空间。：初始化对象的成员数据（私有的、保护的和公有的）以及其他初始化工作。

1．定义构造函数

12

在类定义中定义构造函数：类名（形参表）{ }
在类定义中给出构造函数说明，在类体外定义：类名::类名（形参表）{ }注意：
（1）由系统自动调用。

（2）定义时函数名与类同名，不能指定函数返回值的类型，也不能指定为void类型。（3）可以不带参数，也可带多个参数，也可指定参数的缺省值（当全部指定或无参时为缺省构造函数）。

（4）构造函数的个数为1~n个（1：不定义或只定义一个时；>1时属于构造函数的重载） 缺省构造函数的个数为0个（定义非缺省构造函数）或1个（三种情况之一：不定义，由系统自动产生；定义无参的构造函数；定义所有参数都有缺省值的构造函数）。

（5）若定义的类要说明该类的对象时，构造函数必须是公有的成员函数。

（6）产生对象时，自动根据参数选择调用构造函数。

（7）转换构造函数是带有一个参数的构造函数，用来把参数转换为构造函数所在类的对象。（8）当转换构造函数中的参数为对象的引用时，则为拷贝构造函数。

2．当类中有对象成员时的构造函数的定义
新类（参数表0）：成员1（参数表1），成员2（参数表2），…，成员n（参数表n）{ ………… }
注意：
（1）参数表0必须提供各对象成员参数表中的参数及初始化新类的非对象成员所需的参数

3．定义析构函数类名::~类名（）{… } // 函数体
（2）构造函数的调用顺序：对象成员所属类的构造函数（按对象成员说明的顺序依次调用），自己的构造函数

注意：

（4）析构函数不允许重载、不可以继承
（5）析构函数的调用顺序与构造函数的顺序相反

第11章 继承与派生
1．继承（利用已有的数据类型定义出新的数据类型）
在继承关系中，被继承的类称为基类或父类，而通过继承关系定义出来的新类则被称为派生类或子类。

1）单继承（一个派生类从一个基类派生）
class派生类名：访问方式 基类名 //基类必须已存在
{ 派生类中的新成员 }；
2）多重继承（一个派生类从多个基类派生）
class派生类名：访问方式 基类名1，访问方式基类名2……
{ 派生类中的新成员 }；
2．访问方式即继承方式，可以为public、private或protected，如果省略，则默认为private。1）公有继承

基类中public 和protected成员的访问属性在派生类中不变（派生类中的其他成员可

13

以直接访问它们），而基类private成员不可访问。在派生类的外部只能通过派生类的对象访问从基类继承来的public成员。而无论是派生类的成员还是派生类的对象都无法访问从基类继承来的private成员。

2）私有继承
基类的public和protected成员被继承为派生类的private成员，派生类中的其他成 但在派生类的外部无法通过派生类的对象访问它们。而无论是派生类员可以直接访问它们，
的成员还是派生类的对象都无法访问从基类继承来的private成员。

3）保护方式
基类的public和protected成员被继承为派生类的protected成员，派生类中的其他成员可以直接访问它们，但在派生类的外部无法通过派生类的对象访问它们。而无论是派生类的成员还是派生类的对象都无法访问从基类继承来的private成员。

3．派生类构造函数的定义
派生类名：：派生类构造函数名（参数表）：基类名1（参数表1），基类名2（参数表2）……
{
//派生类构造函数的函数体
}
其中，第1个参数表中的参数包含了其后的各个参数表中的参数。

1）派生类构造函数执行的一般次序为：

（2）调用对象成员的构造函数（如果在派生类中存在对象成员的话）类中说明的顺序； ，调用顺序按照它们在（1）调用基类构造函数，调用顺序按照它们被继承时说明的顺序（从左到右），而不是按派生类构造函数在初始化表中的次序；

4．虚基类在派生类的对象中，同名成员在内存中同时拥有多个拷贝，有两种分辨方法，一是使用作用
域运算符唯一标识并分别访问它们；二是将直接基类的共同基类设置为虚基类。

1）使用作用域运算符方法
在需要访问的成员名前加上直接基类名和作用域运算符“::”。其格式是：
直接基类名::数据成员名 或 直接基类名::成员函数名（参数表）
2）虚基类的方法
将直接基类的共同基类设置为虚基类，即在基类的访问方式前加上关键字“virtual“，声明虚基类的格式如下：
class 派生类名：virtual访问方式基类名{ //声明派生类成员 }；
这样虚基类虽然被一个派生类间接地多次继承，但派生类却只继承一份该基类的成员，就避免了在派生类中访问这些成员时的二义性。

3）虚基类机制下的构造函数的执行顺序
虚基类机制下的构造函数的执行顺序与一般多重继承下的构造函数的执行顺序是不同的，其执行顺序如下：
（1）一个类的所有直接基类中，虚基类的构造函数在非虚基类之前调用； （2）如果一个类的所有直接基类中有多个虚基类，则这些虚基类的构造函数的执行顺

序与在派生类中的说明的次序相同；

14

（3）若虚基类由非虚基类派生而来，则仍然先调用基类构造函数，再按照派生类中构造函数的执行顺序调用。

第12章 其他特性
1．虚函数
1）多态性：同样的消息（对类的成员函数的调用）被类的不同对象接收时导致的完全不同的行为的一种现象。

2）两种多态：编译时的多态（静态多态、通过函数的重载在静态联编实现）；运行时的多态（动态多态、通过虚函数在动态联编实现）。

3）多态性的实现：
（1）声明虚函数：在基类中的成员函数原型前加上关键字virtual。

（2）在派生类中对虚函数重新定义功能（原型不变）
（3）在主函数中，定义指向基类的指针使之指向派生类的对象
（4）使用基类指针调用派生类对象的成员函数（虚函数）
4）说明：
（1）虚函数可以在一个或多个派生类中被重新定义，但它要求在派生类中重新定义时必须与基类中的函数原型完全相同，包括函数名、返回值类型、参数个数和参数类型的顺序。

（2）只有类的成员函数才能声明为虚函数，但类的构造函数以及全局函数和静态成员函数不能声明为虚函数。

（3）只有虚函数通过继承才能实现多态性，否则基类指针仅能访问派生类中的基类部分。

6）抽象类（类中声明了纯虚函数或构造函数为非公有）声明了纯虚函数的基类只是用于继承，仅作为一个接口，具体功能在其派生类中实现。
5）纯虚函数： virtual 类型 函数名（参数表）=0；

（2）静态数据成员所占的空间不会随着对象的产生而分配，也不会随着对象的消失
而回收。

（3）必须对类的静态数据成员进行初始化，其初始化语句应写在程序的全局区域中，并且必须指明其数据类型与所属的类名，初始化格式：类型 类名：：变量名=值； （4）访问公有静态数据成员：“对象.成员函数”或“类名::静态数据成员名” （5）访问非公有静态数据成员：只能由成员函数内访问，不能在类外访问
2）静态成员函数（在成员函数前面冠以static关键字）
说明：（1）只能访问类的静态数据成员，而不能访问类中的其他非静态成员
（2）在类的外部调用类中的公有静态成员函数，使用“类名::静态成员函数（）”，不能通过对象名调用公有静态成员函数。在类的外部不能调用类中的私有静态成员函数。

3．友元函数（友元的作用是提高了运行效率，但又破坏了类的封装性）
1）友元函数的定义
在类的定义中加以声明，声明时只需在友元的名称前加上关键字friend，其格式如下： friend 类型函数名（形式参数）；
说明：（1）函数可放在类体中的任何位置，也可放在类体外（如普通函数） （2）友元函数是可以直接访问类的私有成员的非成员函数。是定义在类外的普通函数，

（3）一个函数可以是多个类的友元函数，不过需要在各个类中分别声明
2）友元类
当希望一个类可以存取另一个类的私有成员时，可以将该类声明为另一类的友元类。定义友元类的语句格式：friendclass 类名；类名必须是程序中的一个已定义过的类。

例如，以下语句说明类B是类A的友元类：
class A
{ …
public： friendclass B； //B是A的友元类
…
}；
经过以上说明后，类B的所有成员函数都是类A的友元函数，且能存取类A的私有成员和保护成员。

注意：（1）友元关系不具有对称性，即如果类B是类A的友元类，并不隐含类A是类B的友元类。

（2）友元关系不具有传递性，即如果类B是类A的友元类，而类C是类B的友元类，这并不隐含类C是类A的友元类。

第13章 运算符重载
1．运算符重载：重新定义运算符的功能（不改变运算符的优先级、结合性、操作数个数）

返回值的类型 类名：：operator@（形参表） //@是需要被重载的运算符 { //函数体，重新定义运算符@在指定类中的功能 }
2．重载的定义
1）重载为类的成员函数，格式为：

3．说明： 1）不可重载的运算符：?: :: . * sizeof()
2）“=”、“（）”、“[]”和“->”等运算符不能重载为友元函数
3）当运算符重载为类的成员函数时，函数的参数个数比原来的运算对象少一个（当前对
象为左操作数；++和—后置时有一个int参数作为与前置运算符的区别）
4）当重载为类的友元函数时，参数个数与原运算符的运算个数相同（第一个参数为左操
作数，第二个参数为右操作数；++和—后置时多一个int参数作为与前置运算符的区别）
5）单目运算符最好重载为类的成员函数，而双目运算符则最好重载为类的友元函数。
6）强制类型转换运算符（可以把一种类的对象转换为其他类的对象或内部类型的对象）
重载为类的非静态成员函数，而不能为友元函数。

第14章 文件流
对文件的操作是由文件流类完成的。文件流类在流与文件间建立连接。

文件流分为三种：文件输入流、文件输出流、文件输入/输出流。

对文件的操作过程四步进行：定义文件流类的对象、打开文件、对文件进行读写操作、关闭

需要包含到程序中的头文件是fstream.h.

如： ifstreamifile；//定义一个文件输入流对象
ofstream ofile；//定义一个文件输出流对象
fstream iofile；//定义一个文件输出/输入流对象
2．打开文件 对象名.open(指向文件名的指针filename,打开方式mode,文件属性access) 利用其成员函数open（）打开需要操作的文件，该成员函数的函数原型为： void open（constunsigned char *filename，intmode，intaccess=filebuf：openprot）
；其中：filename为字符型指针，指定要打开的文件名；mode指定文件的打开方式；access指定文件属性，0（一般文件）、1（只读文件）、2（隐藏文件）、3（系统文件）。

注意：
（1）在实际使用过程中，可以根据需要将打开文件的方式用“|”组合起来。如：ios::in|ios::out 表示以读/写方式打开文件
ios::in|ios::binary 表示以二进制读方式打开文件
ios::out|ios::binary 表示以二进制写方式打开文件
ios::in|ios::out|ios::binary 表示以二进制读/写方式打开文件（2）如果未指明以二进制方式打开文件，则默认是以文本方式打开文件。

（3）ifstream流，mode参数的默认值为ios::in；ofstream流，mode的默认值为ios::out3．文件的读写操作
（1）从一个文件中读出数据，使用文件流类的get（读一个字符）、getline（读多个字符）、

文件对象名.get(字符变量名) 文件对象名.getline(字符指针，字符个数，结束符)read成员函数（读多个字符）以及运算符“>>”

入符“<<” 文件对象名.put(字符)
文件对象名.write(字符串,长度)
文件对象名<<数据1<<数据2…
4．文件的关闭 文件对象名.close()

17