第5章类与对象

1、第 5 章 类与对象【本章目标】·结构类型用struct定义，是用户自定义数据类型，由不同类型的数据成员组成。结构变量在内存占有一片连续的存储区间。结构变量成员用圆点运算符和箭头运算符访问。·链表是一种重要的动态数据结构。动态数据的组织特点是可以在程序运行时创建或撤消数据元素。为了描述动态数据结构中元素之间的关系，数据元素类型定义必须包含表示数据关系的指针。我们详细讨论了最简单的动态数据结构单向链表的操作。·类类型是结构类型的拓展，通常用关键字class定义。类是数据成员和成员函数的封装。类的实例称为对象。·数据成员是类的属性，可以为各种合法的C+类型，

2、包括类类型。·成员函数用于操作类的数据或在对象之间发送消息。·类成员由private, protected, public决定访问特性。public成员集称为类的接口。不能在类的外部访问private成员。·构造函数是特殊的成员函数，在创建和初始化对象时自动调用。析构函数则在对象作用域结束时自动调用。·重载构造函数和复制构造函数提供了创建对象的不同初始化方式。当一个对象拥有的资源是由指针指示的堆时，必须定义深复制方式的复制构造函数。·静态成员是局部于类的成员，它提供一种同类对象的共享机制。静态数据成员在编译时建立并初始化存储空间。静态数据成员和

3、静态成员函数依赖于类而使用，与是否建立对象无关。·友员是类对象操作的一种辅助手段。一个类的友员可以访问该类各种性质的成员。·从编译器的观点看，类是一个程序包。定义什么类成员和如何声明成员的访问性质，取决于问题的需要。【教学内容】目录5.1 结构25.2 类与对象145.3 构造函数和析构函数175.4 静态成员275.5 友员315.1 结构结构由数目固定的成员，各成员可以具有不同的数据类型。5.1.1 定义结构和访问结构1定义结构结构类型以关键字struct标识，结构说明语句形式为：struct <标识符>   类型 成员1 ;类型 成员2 ;类型

4、成员n ;  ; 例如，定义职工档案的结构类型：struct Employee1 char name10 ;   long code ;  double salary ;  char *address ;  char phone20 ; ; 2访问结构对结构变量成员访问用圆点运算符：结构变量名 . 成员【例5-1】访问结构变量。#include<iostream.h>struct weather / 声明结构类型 double temp ; double wind ; ; void main() weather today ; /

5、声明结构类型变量today.temp = 10.5 ; / 对结构变量成员赋值today.wind = 3.1 ; cout << "Temp=" << today.temp << endl ; / 按成员输出cout << "Wind=" << today.wind << endl ; 如果用指针访问结构，访问形式为：  *（指针）. 成员  或指针 -> 成员【例5-2】用指针访问结构。#include<iostream.h>#include

6、<string.h>struct person char name20 ; unsigned long id ; float salary ; ;void main() person pr1 ;person *pp ; / 定义结构指针pp = &pr1 ; / 取结构变量地址strcpy( pp->name, "David Marat" ) ; / 对结构成员赋值，等价于(*pp).namepp->id = 987654321; / pp->id 等价于(*pp).idpp->salary = 335.0 ; / pp->

7、salary 等价于(*pp).salarycout << pp->name << 't' << pp->id << 't' << pp->salary << endl ;【例5-3】结构变量赋值。#include<iostream.h>struct weather double temp ; double wind ; yesterday ;void main() weather today ; / 声明同类型变量yesterday.temp = 10.5 ;

8、 yesterday.wind = 3.1 ; today = yesterday ; / 结构变量整体赋值cout << "Temperature= " << today.temp << endl ;cout << "Wind= " << today.wind << endl ;5.1.2 链表程序设计中处理的数据对象每个元素之间往往存在某种关系，要求在数据表示上，不但要存放基本的信息，还要表示与其它元素的连接。这一节仅从程序设计语言的角度，通过最简单的链表结构，介绍对数据关系的存

9、储和操作。1动态链表存储最简单的数据组织形式是线性表。表中除了第一个和最后一个元素外，每一个元素都有一个前驱和一个后继元素。若数据元素是在程序运行中需要动态插入或删除，数组操作显然不方便。可以用如图5.1 所示的"单向链表"表示。图 5.1 单向链表图5.1的链表可用以下的结构类型存放数据：struct node char name20;float salary;node * next;  ;2建立和遍历链表设有说明：struct node  int data; node * next; ; node *head, *p;建立链表的过程可以描述为：生成头

10、结点；while（未结束）  生成新结点；把新结点插入链表；  图5.2所示操作建立第一个结点：图 5.2 建立第一个结点然后建立后续结点。图5.3所示操作把生成结点插入表尾：图 5.3 建立后续结点一旦生成头结点，头指针就不应该移动。p称为跟踪指针。【例5-4】建立单向链表。struct node int date ; node * next ; ; void CreateList(node * & head) /引用参数是表头指针 node * s, * p ; s = new node ;cin >> s->data ;while ( s-&

11、gt;data != 0 ) if( head = NULL ) head = s ;else p->next = s ;p = s ;s = new node ;cin >> s->data ;p->next = NULL ;delete s ; /释放值为0的结点return;【例5-5】遍历链表。void ShowList( node *head ) cout << "now the items of node are: n" ;while( head ) cout << head->date <<

12、; 't' ;head = head->next ;cout << endl ;3插入结点以下讨论各种情况的插入。（1）在表头插入结点在表头插入结点是要使被插结点成为第一个结点，步骤是： 生成新结点； 把新结点连接上链表； 修改表头指针。具体操作见图5.4。图 5.4 在表头插入结点（2）在*p之后插入*s在*p之后插入结点与在表头插入结点的操作相似，不过首先要查找p的位置（见图5.5）。图 5.5 在*p之后插入*s（3）在*p之前插入*s在*p之前插入*s，需要找到*p的前驱结点的地址，所以查找过程要定位于*p的前驱。图5.6的操作设q指针指向*p的前驱结

13、点。图 5.6 在*p之前插入*s【例5-6】用插入法生成一个有序链表。#include<iostream.h>struct list int data ; list * next ; ; /把数据插入有序链表void insert(list * &head, int num ) list * s, *p, *q ;s = new list ;s->data = num ;s->next = NULL ;if ( head = NULL ) /若表空，建立一个结点的链表 head = s ;return ;if ( head->data > s-&g

14、t;data ) /被插数据最小，插入表头 s->next = head ;head = s ;return ;for(q=head,p=head->next; p; q=p,p=p->next) /搜索插入if ( p->data > s->data ) s->next = p ;q->next = s ;return ;q->next = s ; /被插数据最大，插入表尾return ;/输出链表数据void showlist( const list * head ) cout << "now the items

15、of list are: n" ;while( head ) cout << head->data << 't' head = head->next ; cout << endl ;void main() int k ;list * head = NULL ;cin >> k ;while( k != 0 ) /建立有序链表 insert( head, k) ;cin >> k ;showlist( head ) ; /输出链表数据为了找到第一个大于num的结点时完成前插，程序用双跟踪指针查找。q

16、是p的前驱指针，开始查找时指针的初始状态（图5.7）是：图 5.7 开始查找若在链表中找不到大于num的结点，说明num是当前最大值，应该插入表尾。这时，指针的状态（图5.8）如下：图 5.8 查找结束4删除结点删除结点也要根据结点的位置作不同处理，还要注意释放被删结点。（1）删除头结点操作见图5.9。图 5.9 删除头结点（2）删除 *p删除结点*p，需要知道其前驱结点指针。操作见图5.10。图 5.10 删除结点 *p【例5-7】从头指针为head的链表中删除值等于key的结点。struct list int date ; list * next ; ;void del( list * &

17、amp; head, int key ) list *p ;if ( !head ) cout << "List null! n" ; return ; if ( head->data = key ) /被删结点是头结点 p = head ;head = head->next ;delete p ;cout << key << " the head of list have been deleted.n" ;return ;for( list * pg = head ; pg->next ; pg =

18、 pg->next ) /查找并删除结点 if ( pg->next->data = key ) p = pg->next ;pg->next = p->next ;delete p ;cout << key << " have been deleted.n" ;return ;cout << " there is not key:" << key << endl ; /链表不存在key结点return ;【例5-8】约瑟夫（Jonsephus）问题。如图5.

19、11所示，n个人围成一个环，从第i个开始，由1至interval不断报数，凡报到interval的出列，直到环空为止。出列的人按先后顺序构成一个新的序列。例如，n=8，i=2，interval=3，则输出序列为：4 7 2 6 3 1 5 8编程模拟这个游戏。程序的运行情况如图5.12所示。图 5.12 约瑟夫环操作示意#include <iostream.h>#include <iomanip.h>struct jose int code ; jose *next ; ;jose * Create( int ) ;void ShowList( jose * ) ;vo

20、id Out( jose *, int, int ) ;void main() jose * head ; int num , val , beg ;cout << "nplease input the number of total:n" ;cin >> num ; head = Create(num) ; /创建链环ShowList(head) ; /输出链环序号cout << "nplease input the code of begin:n" ; cin >> beg ; /输入开始数数的位置co

21、ut << "nplease input interval of counting:n" ; cin >> val ; /输入报数间隔cout << "the new list is:n" ; Out( head, beg, val ) ; /输出新序列并删除链表jose * Create(int n) jose *h, *p ; h = new jose ; p = h ; for(int i = 1 ; i<=n ; i+) p->code = i ; /赋给每个结点顺序号if(i<n) p-&g

22、t;next = new jose ; p = p->next ; p->next = h ; /构成链环return h ; void ShowList(jose *h) jose *p ; p = h ; do /输出链环 cout << p->code << 't' ; p = p->next ;while(p!=h) ; /注意循环条件void Out(jose *h, int i, int d) jose *p,*q ; int k ; p = h ; for( q = h ; q->next != h ; q =

23、 q->next ) ; /q是p的前驱指针，指向最后建立的结点for( k = 1 ; k<i ; k+) q = p ; p = p->next ; /寻找开始报数的位置while( p != p->next ) /处理链环，直至剩下一个结点 for( k = 1 ; k<d ; k+ ) q = p ; p = p->next ; /报数cout << p->code << 't' ; /输出报到d的结点q->next = p->next ; /删除结点delete p ; p = q->

24、next ;cout << p->code << endl ; /处理最后一个结点delete p ;5.2 类与对象类是在结构的基础上发展而来的。类定义解决了对数据和操作的封装及对对象的初始化。除此之外，面向对象方法的还支持继承、多态机制，为大型软件的复杂性和可重用性提供了有效的途径。5.2.1 定义类和对象C+中，属性以数据的存储结构实现，称为类的数据成员；方法用函数实现，称为成员函数。它们都是类的成员。C+中，类定义的说明语句一般形式为：  class <类名> public:公有段数据成员和成员函数 ;  protected

25、: 保护段数据成员和成员函数 ;  private:私有数据成员和成员函数 ; ;其中，class是定义类的关键字。类成员用关键字指定不同的访问特性，决定其在类体系中或类外的可见性。关键字private用于声明私有成员。protected声明保护成员。public声明公有成员。例如，一个日期类的定义如下：class Date public:  void SetDate( int y, int m, int d );  int IsLeapYear() ;  void PrintDate() ;  private:  int year,

26、 month, day ; ;成员函数在类外定义使用作用域区分符说明,此时函数头的形式为：返回类型 类名 ：函数名（ 参数表 ）成员函数有两个作用：一是操作数据成员，包括访问和修改数据成员；二是用于协同不同的对象操作，称为传递消息。对象是类类型的变量，说明方法与普通变量相同。以下说明workday和holiday都是Date的对象，而pDate是Date类型的指针。Date workday, holiday, *pDate ;5.2.2 访问对象成员公有成员是提供给外部的接口。对象成员的访问形式与访问结构的形式相同，运算符"."和"->"用于访问对

27、象成员。【例5-9】访问对象的公有成员。#include<iostream.h>class Tclass public:int x,y ;void print() cout << x << "," << y ; ; ;void main() Tclass test ;test.x = 100 ; test.y = 200 ; /访问公有段数据成员test.print() ; /调用公有段成员函数cout<<endl; 【例5-10】用指针访问对象成员。#include<iostream.h>class

28、Tclass public :int x,y ;void print() cout << x << "," << y << endl ; ; ;int add( Tclass * ptf ) return ( ptf->x + ptf->y ) ; void main() Tclass test, * pt = new ( Tclass ) ; /说明一个对象 test 和对象指针pt并初始化pt->x = 100 ; pt->y = 200 ; /用对象指针访问数据成员pt->print() ;

29、 /用对象指针调用成员函数test.x = 150 ; test.y = 450 ;test.print() ;cout << "x+y=" << add(&test) ; /把对象地址传给指针参数5.2.3 this指针C+为成员函数提供了一个称为this的指针，this在所有成员函数调用里作为一个隐含参数传送给成员函数。当一个对象调用类的成员函数时，this指针就指向该对象。this是一个隐含指针,它不能被显式说明。this是一个局部变量。 this指针显式使用主要在运算符重载、自引用等场合。this指针是一个常指针，相当于：class_

30、type * const thisclass_type是类类型标识符。这里，this指针一旦初始化就不能被修改和赋值。当成员函数定义为const函数时，this指针被约束为指向常量的常指针。5.3 构造函数和析构函数C+设置构造函数完成对象的初始化，使用析构函数收回内存和完成相关的善后工作。5.3.1 简单构造函数和析构函数构造函数和析构函数的原型是：类名：类名（ 参数表 ）；类名 ： 类名（）；构造函数和析构函数不能定义在私有部分。【例5-11】重写日期类：#include<iostream.h>class Date public:Date() ;Date() ;void Set

31、Date( int y, int m, int d ) ;int IsLeapYear() ;void PrintDate() ;private:int year, month, day ; ;Date: Date() / 构造函数 cout << "Date object initialized.n" ; Date: Date() / 析构函数 cout << "Date object destroyed.n" void Date: SetDate( int y, int m, int d ) year = y ; month

32、= m ; day = d ; int Date:IsLeapYear() return ( year%4=0 && year%100!=0 ) | ( year%400=0 ) ; void Date:PrintDate() cout << year << "/" << month << "/" << day << endl ; void main() Date d ;d.SetDate(2001,10,1) ;d.PrintDate() ;5.3.2 带参数的构造

33、函数建立一个对象时，可借助带参数的构造函数用特定的数据初始化对象的数据成员。【例5-12】带参数的构造函数。#include<iostream.h>class Date public:Date(int,int,int) ;Date() ;void SetDate( int y, int m, int d ) ;void IsLeapYear() ;void PrintDate() ;private:int year, month, day ; ;Date: Date(int y, int m, int d) year = y ; month = m ; day = d ;cout

34、<< year << "/" << month << "/" << day << ": Date object initialized." << "n" ;Date: Date() cout << year << "/" << month << "/" << day << ": Date object destr

35、oyed." << "n" ; void Date: SetDate( int y, int m, int d ) year = y ; month = m ; day = d ; void Date:IsLeapYear() if ( year%4 = 0 && year%100 != 0 | year%400 = 0 )cout << "Is leap year.n" ;elsecout << "Is not leap year.n" ;void Date:PrintD

36、ate() cout << year << "/" << month << "/" << day << endl ; void main() Date d1( 2000, 5, 1 ) ;Date d2( 2001, 10, 1 ) ;d1.SetDate( 1998, 6, 15 ) ;d1.PrintDate() ;d1.IsLeapYear() ;d1.SetDate( 2000, 9, 23 ) ;d1.PrintDate() ;d1.IsLeapYear() ;带参数的构造

37、函数还有另外一种称为"初始式"的形式对数据成员置初值。形式为构造函数名 (变元表): 数据成员1 (变元表), , 数据成员n (变元表) /* */ 当类定义包含类类型成员时，构造函数初始式可以调用成员类的构造函数。【例5-13】对象成员初始化。#include<iostream.h>class A public:A(int x):a(x) int a ; ;class B public:B(int x, int y) : aa(x), b(y) void out()cout << "aa = " << aa.a &

38、lt;< endl << "b = " << b << endl ;private:int b ;A aa ; ;void main() B objB(3,5) ;objB.out() ;如果对象是由new运算符动态创建，delete运算会自动调用析构函数。【例5-14】改写例5-12的main函数。#include<iostream.h>class Date public:Date(int,int,int) ;Date() ;void SetDate( int y, int m, int d ) ;void IsLea

39、pYear() ;void PrintDate() ;private:int year, month, day ; ;Date: Date(int y, int m, int d) year = y ; month = m ; day = d ;cout << year << "/" << month << "/" << day << ": Date object initialized." << "n" ;Date: Date()

40、 cout << year << "/" << month << "/" << day << ": Date object destroyed." << "n" ; void Date: SetDate( int y, int m, int d ) year = y ; month = m ; day = d ; void Date:IsLeapYear() if ( year%4 = 0 && year%100 !

41、= 0 | year%400 = 0 )cout << "Is leap year.n" ;elsecout << "Is not leap year.n" ;void Date:PrintDate() cout << year << "/" << month << "/" << day << endl ; /改写例5-12的main函数void main() Date * pd ;pd = new Date( 1982

42、, 6, 6 ) ;pd -> PrintDate() ;delete ( pd ) ; / 调用析构函数5.3.3 重载构造函数构造函数与普通函数一样，允许重载。当Date类具有多个构造函数，创建对象时，将根据参数匹配调用其中一个。5.3.4 复制构造函数创建对象时，若用一个已有的同类型对象的数据进行初始化，要求构造函数的参数为自身类类型的引用，这种函数称为复制构造函数。C+为每一个类定义一个默认版本的复制构造函数，程序员也可以定义用户版本的复制构造函数。复制构造函数有一个类类型的引用参数：类名 ：类名（ const 类名 & 引用名 , ） ；为了保证所引用对象不被修改，通常

43、把引用参数说明为const参数。1调用复制构造函数的时机复制构造函数通常用于对象初始化和传递对象参数。【例5-15】用已有对象初始化新创建对象。#include<iostream.h>class Location public :Location ( int xx = 0, int yy = 0 ) X = xx ; Y = yy ; Location ( Location & p ) ;int GetX() return X ; int GetY() return Y ; private : int X, Y ; ;Location:Location(Location &

44、amp; p) X = p.X ;Y = p.Y ;cout << "Copy_constructor called." << endl ; void main() Location A(1,2) ;Location B(A) ; / 调用复制构造函数cout << "B:" << B.GetX() << " , " << B.GetY() << endl ;函数参数是类类型，调用函数时要调用复制构造函数，用实际参数初始化形式参数。【例5-16】使用对

45、象参数的函数。#include <iostream.h>class Location public:Location( int xx = 0 , int yy = 0 ) ;Location( Location & p ) ;Location() ;int GetX () return X ; int GetY () return Y ; private : int X, Y ; ;Location :Location( int xx , int yy ) X = xx ;Y = yy ;cout << "Constructor Object.n&qu

46、ot; ; Location :Location() cout << X << "," << Y << " Object destroyed." << endl ; Location:Location( Location & p ) /复制构造函数 X = p.X ; Y = p.Y ; cout << "Copy_constructor called." << endl ; void f( Location p ) cout <<

47、 "Funtion:" << p.GetX() << "," << p.GetY() << endl ; void main() Location A(1,2) ;f(A) ;当函数返回类类型时，也要通过复制构造函数建立临时对象。【例5-17】返回类类型的函数。#include <iostream.h>class Location public :Location(int xx = 0, int yy = 0) X = xx ; Y = yy ; cout << "Obje

48、ct constructed." << endl ; Location(Location & p) ;Location()cout << X << "," << Y << "Object destroyed." << endl ; int GetX() return X ; int GetY() return Y ; private : int X, Y ; ;Location:Location(Location & p) X = p.X ; Y = p.Y

49、 ; cout << "Copy_constructor called." << endl ; Location g() Location A(1,2) ; return A ; void main() Location B ; B = g() ; 2浅复制和深复制当一个对象拥有的资源是由指针指示的堆时，默认复制构造函数仅作指针（地址）复制，而不重新分配内存空间；当对象作用域结束后，析构函数又会重复释放堆，产生错误。这时需要使用用户自定义的复制构造函数。【例5-18】一个有问题的程序。程序执行效果如图5.12所示。图 5.12 默认复制构造函数创建的

50、对象默认构造函数使对象Obj1和对象Obj2共享内存空间，主函数结束析构Obj1 时，指针所指内存已释放，产生"释放空指针"的错误。为此，应该定义用户版本的复制构造函数。#include<iostream.h>#include<string.h>class name public :name(char *pn) ; name() ;protected : char *pname ;int size ; ;name:name(char *pn) cout <<" Constructing " << pn &l

51、t;< endl ;pname = new charstrlen(pn)+1 ;if (pname!=0) strcpy(pname,pn) ;size = strlen(pn) ;name: name() cout << " Destructing " << pname << endl ;pname0 = '0' ;delete pname ;size = 0 ;void main() name Obj1("NoName") ;name Obj2 = Obj1 ; /调用默认版本的复制构造函数【

52、例5-19】使用自定义复制构造函数。调用自定义复制构造函数创建对象的情形如图5.13所示。图 5.13 自定义复制构造函数创建对象#include<iostream.h>#include<string.h>class name public :name ( char *pn ) ;name(name &Obj) ; name() ;protected : char *pname ;int size ; ;name:name ( char *pn ) cout << " Constructing " << pn <

53、< endl ;pname = new charstrlen(pn)+1 ;if(pname!=0) strcpy(pname,pn) ;size = strlen(pn) ;name:name(name &Obj) /定义复制构造函数 cout << " Copying " << Obj.pname << " into its own blockn" ;pname = new charstrlen(Obj.pname)+1 ;if (pname!=0) strcpy(pname, Obj.pname)

54、;size = Obj.size ;name: name() cout << " Destructing " << pname << endl ;pname0 = '0' ;delete pname ;size = 0 ;void main() name Obj1("NoName") ;name Obj2 = Obj1 ;5.4 静态成员当类成员冠以static声明时，称为静态成员。"静态"是指它提供一种同类对象的共享机制；"成员"是指它具有普通类成员的访问特性。

55、5.4.1 静态数据成员静态数据成员要求在类中声明，在类外定义。static数据成员作用域是类，类外可以用"类名："作限定词，或通过对象访问。【例5-20】静态数据成员的声明和初始化。#include<iostream.h>class counter static int num ;public :void setnum(int i) num = i ; / 成员函数访问静态数据成员void shownum() cout << num << 't' ; ;int counter:num = 0 ; / 初始值为0,可缺省v

56、oid main () counter a , b ;a.shownum() ;b.shownum() ;a.setnum(10) ;a.shownum() ;b.shownum() ;cout<<endl;【例5-21】使用公有静态数据成员。#include<iostream.h>class counter public :void setnum ( int i ) num = i ; void shownum ( ) cout << num << 't' ; static int num ; / 公有静态数据成员 ;int c

57、ounter : num = 1 ; / 初始值为1void main() int i ;for( i = 0 ; i < 5 ; i + ) counter:num += i ;cout << counter:num << 't' ;cout<<endl;5.4.2 静态成员函数当一个成员函数冠以static声明时，称为静态成员函数。静态成员函数提供了一个不依赖于类数据结构的共同操作，它没有this指针。静态成员函数具有一般成员函数的权限，它可以访问类中的所有成员。【例5-22】某商店经销一种货物。货物购进和卖出时以箱为单位，各箱的重

58、量不一样，因此，商店需要记录目前库存的总重量。现在用C+模拟商店货物购进和卖出的情况。#include<iostream.h>class Goods public :Goods ( int w) weight = w ; total_weight += w ; ; Goods() total_weight -= weight ; ;int Weight() return weight ; ; /静态成员函数，返回货物总重量static int TotalWeight() return total_weight ; ; Goods *next ;private :int weight

59、 ;static int total_weight ; /静态数据成员，记录货物总重量 ;int Goods:total_weight = 0 ;/购进货物，从表尾插入结点void purchase( Goods * &f, Goods *& r, int w ) Goods *p = new Goods(w) ;p -> next = NULL ;if ( f = NULL )f = r = p ;else r -> next = p ; r = r -> next ; /售出货物，从表头删除结点void sale( Goods * & f , Goods * & r ) if ( f = NULL ) cout << "No any goods!n" ;re