第5章C++语言进阶[教育课资]

1、第5章C+语言进阶教学提示：在第4章已经介绍了C+中关于类的大部分内容，本章继续讲解和类相关的内容。主要包括：友元，this指针，类的继承，多态和虚拟函数等，它们是编写面向对象程序的基础。教学目标：掌握友元函数和友元类的概念，掌握友元的使用，理解友元的局限性；理解this指针的概念；理解多态性的含义，多态对于继承的意义，掌握多态的工作原理；理解抽象类与具体类的区别；熟练运用类的继承、类的多重继承、虚函数、纯虚函数，编写层次分明、结构清晰的程序。5.1 友元和this指针5.1.1 友元1. 友元函数在第3章重载运算符时已经用到了友元函数，但并没有对友元函数作详细的介绍。其实，友元函数和普通的C

2、+函数不同的只是，它可以访问类的保护和私有成员。利用友元函数使程序编写更加方便，提高了效率。但是使用友元函数破坏了类的封装性，因此一般只在能够提高程序效率的前提下使用友元。定义友元函数很简单，在类里声明一个普通函数，标上关键字friend，就成了该类的友元，就可以访问该类的一切成员。例如，下面的例子定义了两个类，rect类和point类，并声明函数inrect是它们的友元函数，因此inrect函数可以访问rect类和point类中的非公有成员。 class rect； class point private： int x； int y； public： point(int xx=0，int y

3、y=0)：x(xx)，y(yy) ； friend int inrect(const point&，const rect&)；/声明友元函数 ； class rect private： point p1； point p2； public： rect(int x1，int y1，int x2，int y2):p1(xl，y1)，p2(x2，y2) ； friend int inrect(const point&，const rect&)；/声明友元函数 ； /友元函数的定义 int inrect(const point &p，const rect &r) /友元函数内可以访问类的私有成员 if

4、(p.x=r.p2.x)&(p.y=r.p2.y) return l； if(p.x=r.p1.x)&(p.x=r.p1.y)&(p.y=r.p2.y) return 1； return 0； 友元函数不是类的成员函数，但它是类的朋友，因而友元函数也可以访问类的全部成员。友元函数的声明可以放在类定义的任何部位，可以在public区，也可以放在private区，意义完全相同。友元函数的定义部分在类定义体的外面，一般和类的成员函数放在一起，以便在类重用时，友元函数可以一起重用。2.友元成员函数当一个类的某个成员函数被宣布为另一个类的友元时，在这个成员函数内就可以访问另一个类的非公有数据。例如： c

5、lass student； class teacher public： void teacher:setscore(student &s，int i) s.score=i； ； class student private： int score； public： friend void teacher:setscore(student &s，int i)； ； teacher类的成员函数setscore(student&s，int i) 被声明为student类的友元，因此teacher类的对象可以通过其成员函数setscore修改student类对象的非公有数据成员。例如： student s

6、1； teacher t1； t1.setscore(s1，90)；3. 友类整个类是另一个类的友元，该友元称为友类，友类的每个成员函数都可以访问另一个类的保护或私有的数据成员。即，当类A宣布为类B的友类时，类A的所有成员函数都可以访问类B的非公有成员。例如： class student； class teacher public： void teacher：setscore(student &s，int i) s.score=i； ； class student private： int score； public： friend class teacher；/友类 / ；友元的作用主要是为

7、了提高效率和方便编程，但随着硬件性能的迅速提高，友元的这点作用已经微不足道，相反，友元破坏了类的封装性，破坏了类的整体操作。所以我们不鼓励使用友元，读者在使用友元时要权衡利弊。5.1.2 this指针this指针隐含于每一个类的成员函数中(静态成员函数除外)，它指向调用该成员函数的对象。当一个对象调用成员函数时，编译程序先将对象的指针地址赋值给this指针，然后调用成员函数，每次成员函数存取数据时都隐含地使用了this指针。通常不显式地使用this指针来引用数据成员。可以用*this来标识调用成员函数的对象。 class room private： int m； public： room(in

8、t i，int j)； void view( ) cout”m=”mendl； /隐含了this指针 cout”m=”mendl；/和上一行的效果相同 ； 例题：分析下面程序的输出结果：/5_1.cpp#include class sampleprivate:int x,y;public:sample( ) sample(int a,int b)x=a;y=b;void copy(sample &c)if(this=&c)cout错误的复制调用endl;/return;elsec.view();void square()x=x*x;y=y*y;void view()coutx=x y=yend

9、l;void main()sample c1,c2(5,5);c2.square();c2.view();c2.copy(c2);c1.copy(c2);程序的执行结果是： 25 25 错误的复制调用 25 255.2 静态成员为了解决数据的共享问题，C+中提出了静态成员的概念。静态成员分为静态成员函数和静态成员变量两种。将数据成员声明为静态的，将使所有的同类对象都拥有同一份静态成员，该静态成员遵守数据封装约定。使用静态成员可以节省内存，因为它是所有对象共有的，只需存储一处，就可以供所有对象使用。静态成员对所有的对象都一样，它的值是可以改变的。类的所有对象都共用static类成员。关键字sta

10、tic可以用来定义类的成员。如果将类的某个成员声明为static，那么你也就告诉编译器：无论创建了多少个类对象，程序中也只有一个static成员的副本。也就是说，类的所有对象都将共用static成员。如果在创建第一个类对象时没有对static成员进行初始化，那么类中所有的static成员都被初始化为零。当你在类中声明一个static成员时，你并没有定义它，所以必须为这个static成员提供一个在类作用域之外的全局定义。我们通过在全局作用域中重新声明static成员变量来定义它，并且使用作用域解析运算符来指定它所在的类。在程序中对static成员变量的定义为static成员变量分配了内存空间。5

11、.2.1 静态数据成员静态数据成员的使用方法：(1) 静态数据成员在声明时前面加static关键字。(2) 静态数据成员的初始化和一般数据成员的初始化不同，静态数据成员初始化格式如下： ：=；初始化在类体外进行，前面不加static，以免与一般的静态变量或者对象混淆。初始化时不加该成员的访问权限控制符public、protected和private。初始化时使用作用域运算符表明该成员所属的类，因此，静态数据成员是类的成员，它不是任何对象独占的成员。(3) 静态数据成员必须初始化。(4) 用类名引用静态数据成员： ：(5) 类和对象都可以对静态数据成员进行改动。下面的示例程序使用到了static

12、变量，请仔细阅读程序并理解程序是如何运行的。/补充例题：（5_2_1.cpp）注意，我们在类ShareVar中声明了静态整数变量num，同时还在程序中将num作为一个全局变量来定义。前面提到过，这样做是必须的，因为在类ShareVar中我们只是声明变量num而没有为它分配内存。由于在程序中没有对变量num作初始化，所以C+默认将num初始化为0，因此第一次调用函数shownum()时，程序输出0。接下来，对象a将num的值设置为10。然后，对象a和b都调用函数shownum()来输出num的值。因为在程序中变量num只有一个副本，并且由对象a和b共用，所以两个函数都将输出10。#include

13、 class ShareVar static int num;public: void setnum(int i) num = i; ; void shownum() cout num ; ;/ 定义类ShareVar的静态成员变量numint ShareVar : num ; int main() ShareVar a, b; a.shownum(); / 输出 0 b.shownum(); / 输出 0a. setnum(10); / 将静态成员变量num的值设为10 a.shownum(); / 输出 10 b.shownum(); / 也输出 10 return 0;l 记住：如果在类

14、中某个成员被声明为static，那么这个成员在程序中就只有一个副本，然后类的所有对象都将共用这个副本。如果static成员变量是类的公有成员，那么可以直接通过类的名字而不是对象的名字来使用这个成员(当然，也可以通过对象的名字来使用)。例如，考虑下面的类ShareVar：class ShareVarpublic： static int hum； void setnum(int i) num = i; ; void shownum() cout num ; ;在上面的定义中，成员变量num是公有的，因此可以直接访问变量num，如下所示：ShareVar：num=100；上面这条语句是通过类的名字和

15、作用域解析运算符来访问变量num，这与类的对象无关。而且，甚至在任何ShareVar类型的对象存在之前，这条语句都是有效的!这样，你可以在创建任何对象之前获得或者设置类的static成员变量的值。下面的程序定义了一个静态数据成员n，在构造函数中定义了n的自增运算，调用一次构造函数，n加1。/5_2.cpp#include class roomprivate: int m;public: static int n; /声明静态数据变量 room(int i):m(i) n+; void view() coutm=mendl; coutn=nendl; room( ) ;int room:n=0;

16、 /静态成员只能在类外部定义，定义的同时必须初始化。void main() room r1(10);/每当调用一次构造函数，n加1。 room r2(20);/r2构造结束后n=2 room r3(30);/r3构造结束后n=3 coutin class room n=room:nendl;/引用静态成员可以用类名程序的执行结果是： in class room n=35.2.2 静态成员函数成员函数也可以被声明为static，但这种用法并不普遍。静态成员函数和静态数据成员一样，它们都属于类的静态成员，而不是对象的成员。static成员函数可以通过类的对象来调用，或者也可以不依赖于任何对象而使用

17、类的名字和作用域解析运算符来调用。在静态成员函数的实现中不能直接引用类的非静态成员，也不能引用this指针，但可以引用类中声明的静态成员(当然，static成员函数也可以访问全局变量和全局函数)。如果静态成员函数中需要引用非静态成员时，可以通过对象来引用。下面的类room定义了静态成员函数view()；它可以引用类的静态成员变量n，但是不能引用非静态成员变量m。 class room private： int m； public： static int n； room(int i)：m(i) n+； static void view( ) /静态成员函数 m+； /error这里不能引用非静态

18、成员 cout”n=”nendl； ；int room：n=0；/定义并初始化静态数据成员n=0下面的程序定义了一个学生类，该类共定义了4个静态成员，一个整型静态成员变量count，它的作用是计数器，用来记录学生的个数；一个student类类型的指针静态成员变量pfirst，用来记录链头指针；一个返回值为空的静态成员函数findname()，它的功能是从链头开始查找某个特定的节点，函数体内设置了一个for循环，循环从链头开始查找，一直查到链尾，如果找到了关键节点，则输出关键节点在链表中的位置，结束循环，如果没有找到则输出“no find并返回；一个返回值为空的静态成员函数view()，它的功能

19、是对链表进行遍历，并在屏幕上依次输出各个节点的name域的值。调用一次student类的成员函数，就在链表头插入一个节点，新插入节点的pnext指针指向插入前的头节点。链表开始时为空，即pfirst为空。具体代码如下：/5_3.cpp#include #include class studentprivate:char name40;int number;static int count; /计数器，用来记录学生的个数static student* pfirst; /链表头指针，student *pnext; /指向链表当前节点的下一个节点public:student(char *);stud

20、ent();static void findname(char *); /查询特定节点static void view(); /遍历链表;int student:count=0; /定义并赋初值0student* student:pfirst=NULL; /定义并赋初值NULL/student类的成员函数student:student(char *pname)strcpy(name,pname);pnext=pfirst;pfirst=this;count+;number=count;/student类的析构函数student:student( ) /析构函数if(pfirst=this)pf

21、irst=pnext;count-;return;for(student* ps=pfirst;ps;ps=ps-pnext)if(ps-pnext=this)ps-pnext=pnext;count-;return;void student:findname(char* pname) /在链表中查找某个关键节点for(student* ps=pfirst;ps;ps=ps-pnext)if(strcmp(ps-name,pname)=0)coutfind it,it is number numberendl;return;coutno findpnext)coutnameendl;void

22、main()student s1(s1);student s2(s2);student s3(s3);student:view();char name40;coutplease put in the name of which you want to findname;student:findname(name);程序运行结果如下： sl s2 s3 please put in the name of which you want to find s2(假如你输入的是s2) find it，it is number 25.3 继 承继承性是面向对象程序设计中最重要的机制，这一机制提供了无限重复

23、利用程序资源的有效途径，该机制自动为一个类提供来自另一个类的操作和数据结构。程序员通过C+语言中的继承机制，可以扩充旧的程序以适应新的需求，这样不仅可以节约程序开发时间和资源，并且可以为未来的程序设计增添新的资源。理解继承性是理解面向对象程序设计所有方面的关键。5.3.1 基类和派生类C+语言的继承机制，允许我们利用已有的数据类型定义新的数据类型，所定义的新数据类型不仅拥有新定义的成员，而且还同时拥有旧的成员。我们称用来派生新类的类为基类，又叫做父类。由基类派生的新类称为派生类，也称为子类。一个派生类可以从一个基类派生，也可以从多个基类派生。从一个基类派生的继承方式叫做单继承；从多个基类派生的

24、继承方式叫做多继承。任何类都可以作为基类，一个基类可以有一个或者多个派生类，一个派生类还可以成为另一个类的基类。定义单继承派生类的一般格式如下： class : / 派生类新定义的成员 其中，派生类名称是新定义的类名，它是从父类中派生的，并且是按照指定的继承方式派生的。继承方式有3种，分别是：public方式，表示公有类继承；protected方式，表示保护基类；private方式，表示私有基类。其中private方式是默认的继承方式。派生类3种继承方式的异同阐述如下：(1) public方式这种方式将基类的protected区成员继承到派生类的protected区，基类的public区的成员

25、继承到派生类的public区。这时基类能作的所有操作，派生类都可以完成，派生类是基类的子类。对于派生类来说，基类的公有成员和保护成员可见，基类的私有成员不可见，派生类不可以访问基类的私有成员。对于派生类对象来说，派生类的对象可以访问基类的公有成员，其他成员是不可见的。注意：在公有继承时，派生类的对象可以访问基类的共有成员，派生类的成员函数可以访问基类的共有成员和保护成员。(2) protected方式这种方式将基类的protected区和public区的所有成员都继承到派生类的protected区。在这种继承方式下派生类不是基类的子类。对于派生类来说，基类的公有成员和保护成员是可见的，基类的保

26、护成员和公有成员都作为派生类的保护成员，并且不能被这个派生类的子类访问；而基类的私有成员是不可见的，派生类不能访问基类的私有成员：对于派生类的对象来说，基类的所有成员都不可见。所以对于保护继承来说，基类的成员只能由直接派生类访问，而无法再往下继承。(3) private方式将基类的protected区和public区的所有成员都继承到派生类的private区。在这种继承方式下派生类也不是基类的子类。对于派生类来说，而基类的公有成员和保护成员是可见的，基类的保护成员和公有成员都作为派生类的私有成员，并且不能被这个派生类的子类访问：而基类的私有成员是不可见的，派生类不能访问基类的私有成员；对于派生

27、类的对象来说，基类的所有成员都不可见。所以对于私有继承来说，基类的成员只能由直接派生类访问，而无法再往下继承。如果基类与派生类中都有用户自定义的构造函数，基类的构造由基类的构造函数完成，派生类的构造函数负责提供派生类和基类的构造参数并构造派生类。由于构造函数不能被继承，所以派生类的构造函数必须通过调用基类的构造函数来初始化基类的对象。因而在定义派生类的构造函数时，除了对自己的数据成员进行初始化外，还必须负责调用基类构造函数，初始化基类的数据成员。派生类的构造函数一般格式如下：()：()， () / 派生类数据成员初始化派生类构造函数的调用顺序如下：(1) 基类的构造函数(2) 子对象类的构造函

28、数(3) 派生类的构造函数当对象被删除时，派生类的析构函数被执行。由于析构函数也不能被继承，因此在执行派生类的析构函数时，基类的析构函数也将被调用。执行顺序是先执行派生类的析构函数，再执行基类的析构函数，与执行构造函数时的顺序正好相反。5.3.2 多重继承多继承的一般格式：class ：，其中，基类可以有两个或者两个以上，各个基类之间用逗号隔开，每个基类名前都指明继承方式，默认的继承方式是private方式。例如，下面的程序中，类C继承于两个基类，一个基类是A，另一个基类是B。/5_4.cpp#include class A /基类A的定义int a;public:A(int i)a=i;co

29、utA constructorendl;void view( )couta=aendl;class B /基类B的定义int b;public:B(int j)b=j;coutB constructorendl;void view()coutb=bendl;class C:public A,public B /定义子类C，它继承于基类A和基类Bint c;public:/派生类c的构造函数在初始化自己的数据成员时，必须负责调用基类构造函数初始化基类的数据成员。C(int k):A(+k),B(-k)c=k;coutC constructorendl;void view( )A:view( );

30、B:view( );coutc=cendl;void main()C c1(10);c1.view();本程序的执行结果是： A constructor B constructor C constructor a=1l b=10 c=105.4 多态性与虚拟函数学习目标：l 理解多态性的概念l 理解如何声明和利用虚拟函数来实现多态性l 理解抽象类和具体类的区别l 理解C+如何实现虚拟函数和动态绑定5.4.1 多态性C+允许子类的成员函数重载父类的成员函数，程序在运行时能够依据其类型确认调用哪个函数的能力，称为多态性。多态性是面向对象程序设计的重要特性，是指同一个接口名称具有多种功能。利用多态性

31、，用户只需发送一般形式的消息，而将所有的实现留给接收消息的对象，对象根据所接收的消息做相应的操作。函数重载和运算符重载就是一类简单的多态性。如果语言不支持多态，则不能称其是面向对象的语言。只支持类不支持多态的语言，我们称其为基于对象的。如Ada语言、Visual Basic语言。为了指明某个成员函数具有多态性，必须用关键字virtual声明其为虚拟函数。例如，下面的程序在它的基类中定义了虚函数fn( )，在派生类中又重新定义了虚函数fn( )，因此实现了多态的功能。/5_5.cpp#include class Basepublic:virtual void fn( )如果基类中的一个函数（例如

32、fn()）被声明为virtual，用基类的指针或引用来指明派生类对象并用该指针或引用来调用该函数，程序会根据对象的类型动态选择相应的派生类的fn()函数。这就是动态绑定。如果用对象和圆点(.)运算符调用该函数（如der.fn( )）则是静态绑定（即是在编译时确定的）。 coutin base classendl;class Derive:public Basepublic:virtual void fn( )coutin derive classendl;在test( )函数中，b是基类Base的引用形参，Base类对象和Derive对象都可以作为参数传递给b。而fn( )是Base类的虚函数

33、，所以b.fn()的调用要到运行时才能确定调用的是基类的fn( )还是派生类的fn( )。;void test(Base &b)b.fn();void main()由于函数fn( )标识为虚函数，编译时系统遇到b.fn( )后，会将其作为后期绑定处理，保证在运行时确定调用的是基类的fn( )，还是派生类的fn( )。Base b;Derive der;coutcalling test(b)endl;test(b);coutcalling test(der)endl;test(der);程序运行结果为： calling test(b) in base class calling test(der

34、) in derive class编译通常是在前期绑定状态下工作的，只有对于虚函数，才把它作为后期绑定来实现。多态性增加了一些数据存储和执行指令的开销，但是在多数情况下，这种额外的开销不会对程序运行效率有大的影响。因此，在类中应将成员函数尽可能设为虚函数。绑定是指一个计算机程序自身彼此关联的过程。按照绑定所进行的阶段不同，可分为前期绑定和后期绑定。又称为静态绑定和动态绑定。前期绑定是指绑定工作出现在编译链接阶段，这种绑定过程在程序开始运行之前已经完成。也叫做静态联编或静态绑定。后期绑定是指编译程序在编译阶段不能确定将要调用的函数，只有在程序运行时才能确定要调用的函数，为此要求绑定工作在程序运行

35、时进行。这种在程序运行时进行的绑定工作称为后期绑定，也叫做动态联编或动态绑定。5.4.2 虚拟函数虚拟函数(virtual function)指的是某个函数在基类中被声明为virtual，而在派生类中又重新定义了这个函数。虚拟函数是动态绑定的基础。虚拟函数是成员函数，而且是非静态的成员函数。声明虚拟函数的语法形式为：virtual 函数类型 函数名称( )其中virtual是声明虚拟函数的关键字。虚拟函数简称为虚函数。如果一个类的成员函数声明为虚函数，这就意味着该成员函数可能在它的派生类中有不同的实现。动态绑定只能通过指针或者引用标识对象来操作虚函数，当声明一个指向基类的指针时，该指针也适用于

36、相应的派生类。如果使用一般类型标识对象操作虚函数，则将采用静态绑定方式调用虚函数。例如：/5_6.cpp#include class basepublic:virtual void f1()coutf1 function of baseendl;virtual void f2()coutf2 function of baseendl;virtual void f3()coutf3 function of baseendl;void f4() /一般成员函数coutf4 function of baseendl;class subclass:public basepublic:virtual v

37、oid f1() /多态coutf1 function of subclassendl;virtual void f2(int x) /参数不同无法实现多态coutf2 function of subclassendl;virtual void f4() /在基类中没有被声明虚函数，不能实现多态coutf4 function of subclassf1();p-f2();p-f3();p-f4(); p=≻p-f1();p-f2();p-f3();/在子类subclass中没有重载父类base的成员函数f3()，不能实现多态p-f4();程序的运行结果是：f1 function of b

38、asef2 function of basef3 function of basef4 function of basef1 function of subclassf2 function of basef3 function of basef4 function of base由上面的程序可以看出：(1) 虚函数在基类与派生类中的声明(包括函数名、返回值类型和参数列表)必须一样才能实现多态。(2) 只有类的成员函数才能声明为虚函数。(3) 内联函数、构造函数(调用时产生)、静态成员函数(不属于对象)不能声明为虚函数。(4) 对虚函数调用的解释取决于调用它的对象。(5) 对非虚函数调用的解释取

39、决于调用它的指针或引用的类型。5.4.3 纯虚函数和抽象类纯虚函数是一种特殊的虚函数，它的定义格式是：virtual ()=0；在许多情况下，在基类中不能对虚函数给出有意义的实现，而把它声明为纯虚函数，实现留给基类的派生类做。抽象类：带有纯虚函数的类是抽象类。抽象类是一种特殊的类，它是为了抽象和设计的目的而建立的，抽象类的作用是将子类组织在一个继承层次结构中，给子类提供一个公共的根。抽象类的特点： 抽象类只能做其他类的基类，不能建立抽象类的对象。 抽象类不能用作参数类型、函数返回类型。 抽象类可以声明指针和引用，指针指向它的派生类，实现多态性。例如，下面的程序定义了一个抽象类shape，该类中

40、包含一个纯虚函数view()的声明，在它的派生类rect(长方形)、square()正方形和circle(圆)中分别对纯虚函数view()定义了不同的实现。/5_7.cpp#include const double pi=3.1415;class shape /抽象类protected:double x,y;public:void setvalue(int i,int j=0)x=i;y=j;virtual void view( )=0; /纯虚函数;class rect:public shapepublic:void view()cout长方形面积是:x*yendl;class square

41、:public shapepublic:void view()cout正方形面积是:x*xendl;class circle:public shapepublic:void view()cout圆面积是:pi*x*xsetvalue(3 , 5);p0-view();p1=&s;p1-setvalue(3);p1-view();p2=&c;p2-setvalue(3);p2-view();程序运行结果如下： 长方形面积是：15 正方形面积是：9 圆面积是：28.27355.5 虚拟析构函数在析构函数前面加上virtual关键字，则析构函数被声明为虚拟析构函数，虚拟析构函数的格式如下： clas

42、s virtual ( )； ；如果基类的析构函数被声明为虚拟析构函数，那么它的派生类的析构函数也是虚拟的。虚拟析构函数的目的是在用delete运算符删除对象时，能保证析构函数被正确地执行。因为设置虚拟析构函数后，是用动态绑定的方式选择析构函数的。例如，下面的程序在基类base中析构函数被定义为虚拟析构函数，派生类der的析构函数也被定义为虚拟析构函数。在main主函数中定义了一个基类的指针b，指向派生类的对象。/5_8.cpp#include class basepublic:virtual base() /声明为虚拟析构函数coutdestructing baseendl;class de

43、r:public basepublic:char *ch;der(int i)ch=new chari;virtual der() /声明为虚拟析构函数delete ch;coutdestructing derendl;void main()base *b=new der(20);delete b;程序的运行结果是： destructing der destructing base假如在基类base中析构函数不用虚函数，则输出结果如下： destucting base5.6 上机指导5.6.1 类的继承编写一个统计动物种类的程序。目的：练习应用类的继承，加深理解继承的概念，在定义类时活学活用类

44、的继承。首先声明一个名为Animal(动物)的基类，然后再创建两个派生类，一个是Mammal(哺乳动物)，一个是Bird(鸟类)。子类Mammal含有子女数和读取子女数的成员函数NumOffspring()；子类Bird含有生蛋数、是否筑巢，以及取生蛋数的成员函数GetEggs( )。成员函数ShowMannal()和ShowBird()的功能是分别输出各自的对象参数。程序的具体源代码如下：/5_9.cpp#include #include #define FALSE 0#define TRUE 1/Animal类定义class Animalpublic:Animal(const char *s) /构造函数strncpy