【文档说明】C面向对象程序设计课件.ppt，共(137)页，3.451 MB，由小橙橙上传

转载请保留链接：https://www.ichengzhen.cn/view-44826.html

以下为本文档部分文字说明：

高级语言程序设计教学课件1C++面向对象程序设计信息科学与工程学院罗宪面向对象程序设计信息科学与工程学院高级语言程序设计教学课件2第三章类和对象(教材①P180-P288)本章主要介绍：类和对象的基本概

念（类的定义、对象的定义）构造函数与析构函数（对象的初始化）对象数组、对象指针及引用向函数传递对象静态成员常量对象及常量成员友元对象成员对象的存储类标识符的作用域、可见性和名空间面向对象程序设计信息科学与工程学院高级语言程序设计教学课

件3第一节类和对象的基本概念一、结构与类C++中的类实际上是在C语言的结构体的基础上扩充得到的。即C++的结构体的成员中可用函数——成员函数：C++结构体的成员分为数据成员及成员函数数据成员分为公有成员（public)、私有成员(private

)、保护成员（protected)。㈠C++对结构的扩充例【3.1】已知复数的实部、虚部，分别输出复数的实部、虚部及绝对值——初步熟悉成员函数面向对象程序设计信息科学与工程学院高级语言程序设计教学课件4第一节类

和对象的基本概念#include<iostream.h>#include<math.h>structcomplex{doublereal;doubleimag;voidinit(doubler,doublei){real=r;imag=i

;}doublerealcomplex(){returnreal;}doubleimagcomplex(){returnimag;}doubleabscomplex(){doublet;t=sqrt(re

al*real+imag*imag);returnt;}};面向对象程序设计信息科学与工程学院高级语言程序设计教学课件5第一节类和对象的基本概念voidmain(){complexA;A.init(3.0,4.0);cout<<"rea

lofcomplexA=";cout<<A.realcomplex()<<endl;cout<<"imagofcomplexA=";cout<<A.imagcomplex()<<endl;cout<<"absofcomplexA=";cout<<A

.abscomplex()<<endl;}程序运行输出结果：realofcomplexA=3imagofcomplexA=4absofcomplexA=5面向对象程序设计信息科学与工程学院高级语言程序设计教学课件6第一节类和对象的基本概念C++结构的扩充：在C++中，在定

义一个结构时，可以定义成员函数；如程序中的init()、realcomplex()、imagcomplex()、abscomplex()等；在C++的结构中，成员分公有成员(public)和私有成员(private)

，私有成员只能在结构内使用，公有成员既可以在结构内使用，亦可在其它地方使用；在结构中，未指明为公有成员或私有成员的成员默认为公有成员；成员函数的调用方法：结构变量.成员函数(实参表)；上例结构体的定义部分程序可改为：面向对象程序设计信息科学与工程学院高级语言程序设计教学课件7

第一节类和对象的基本概念structcomplex{privatedoublereal;doubleimag;publicvoidinit(doubler,doublei){real=r;imag=i;}doublerealcomplex(){return

real;}doubleimagcomplex(){returnimag;}doubleabscomplex(){doublet;t=sqrt(real*real+imag*imag);returnt;}};面向对象程序设计信息科学与工程学院高级语言程序设计教学课件8第一节类和对象的

基本概念㈡C++对结构的扩充——类C++提供了一种比结构体更为安全的数据类型——类。类与结构的扩充形式非常相似，但凡是未定义为公有成员（public)或保护成员(protected)的成员均为私有成员(private)——封装性的体现。例【3.2】将例【3.1】用类定

义。面向对象程序设计信息科学与工程学院高级语言程序设计教学课件9第一节类和对象的基本概念#include<iostream.h>#include<math.h>classcomplex{private:dou

blereal;doubleimag;public:voidinit(doubler,doublei){real=r;imag=i;}doublerealcomplex(){returnreal;}doublei

magcomplex(){returnimag;}doubleabscomplex(){doublet;t=sqrt(real*real+imag*imag);returnt;}};面向对象程序设计信息

科学与工程学院高级语言程序设计教学课件10第一节类和对象的基本概念voidmain(){complexA;A.init(3.0,4.0);cout<<"realofcomplexA=";cout<<A.realc

omplex()<<endl;cout<<"imagofcomplexA=";cout<<A.imagcomplex()<<endl;cout<<"absofcomplexA=";cout<<A.abscomplex()<<endl;}面向对象程序设计信息科学与工程学院高级语言程序设计教学

课件11第一节类和对象的基本概念㈢类的声明（定义）1、格式：class类名{[private:]私有数据成员或成员函数public:公有数据成员或成员函数protected保护数据成员或成员函数}；面向对象程序设计信息科学与工程学院高级语言程序设计教学课件12第一节类和对象的基本概念2、

说明：类的声明（定义）中，private、protected、public可以按任意顺序出现任意次；但通常private放在前面，protected放在中间，public放在最后面；类中的数据成员通常说明为私有成员，而成员函数通常说明公有成员，保护成员主要用作继承。面向对象程序设计信息科学与工

程学院高级语言程序设计教学课件13第一节类和对象的基本概念例【3.3】定义一个日期类，其要求为：设置年、月、日的具体值；判断该年是否为闰年；显示年、月、日1、分析类名（抽象数据类型）：Date数据成员：用整型数year、month、day表示年、

月、日；成员函数（对Date的操作）：setdate():设置日期isleapyear():判断是否为闰年printdate():显示日期面向对象程序设计信息科学与工程学院高级语言程序设计教学课件14第一节类和对象的基本概念2

、类的定义#include<iostream.h>classDate{private:intyear,month,day;public:setdate(inty=2000,intm=1,intd=1){year=y;month=m;day=d;

}intisleapyear(void);voidprintdate(void){cout<<year<<'-'<<month<<'-'<<day<<endl;}};intDate::isleapyear(

void){intp;p=(year%4==0&&year%100!=0)||(year%400==0);returnp;}面向对象程序设计信息科学与工程学院高级语言程序设计教学课件15第一节类和对象的基本概念4、类的测试（主函数）voidmain(voi

d){Dateda1,da2;da1.setdate(2004,5,1);da2.setdate(2006,10,1);da1.printdate();da2.printdate();cout<<"2004year";

if(da1.isleapyear())cout<<"isaleapyear."<<endl;elsecout<<"isnotaleapyear."<<endl;cout<<"2006year";if(da2.isleapyear())cout<<"isaleapyear."<<end

l;elsecout<<"isnotaleapyear."<<endl;}面向对象程序设计信息科学与工程学院高级语言程序设计教学课件16第一节类和对象的基本概念㈣成员访问限制1、公有成员：public——所定义的成员是开放的，可在任何地方访问（类内部及程序的其他地方）；

2、私有成员：private——所定义的成员是隐藏的，只能在类内部访问，不能在程序的其他地方访问；3、保护成员：protected——所定义的成员是半开放的，可在类内部访问，也可在其派生类中访问，但不能在程序的其他部分访

问。数据成员通常定义为私有成员，以实现数据的隐藏；成员函数通常设为公有的，以通过消息传递访问数据成员;保护成员主要用于继承。面向对象程序设计信息科学与工程学院高级语言程序设计教学课件17第一节类和对象的基本概念二、数据成员1、一般定义格式：类型数据成员名2、说

明数据成员中，不能使用auto、register、extern等进行说明；（请思考为什么？）；——定义类时，计算机并不给数据成员分配内存空间，在定义对象时才分配空间；不能在定义时给类中的成员赋初值。（请思考为什么）数据成员既可为基本数据类型，也可以是复杂数据类型（数组、指针、引用、结构体

，也可以是类变量等）面向对象程序设计信息科学与工程学院高级语言程序设计教学课件18第一节类和对象的基本概念三、成员函数在面向对象程序设计中，成员函数也称方法——是面向对象程序设计消息传递机制的实现方式。㈠在类外定义在类中只给出成员函数的原型，成员函数体在类的外部定义。格式：返回

类型类名::函数名(形参表){函数体}例【3.4】定义座标点的类point面向对象程序设计信息科学与工程学院高级语言程序设计教学课件19第一节类和对象的基本概念1、分析类名（抽象数据类型）：Point数据成员：用实型数表示点的x、y坐标；成员函数（对Point

的操作）：set_point():设置点的坐标；read_x():读取x值；read_y():读取y值；move():点的移动；2、类的定义面向对象程序设计信息科学与工程学院高级语言程序设计教学课件20第一节类和对象的基本概念classpoint{private:floatx,

y;public:voidset_point(floata,floatb);floatread_x(void);floatread_y(void);voidmove(floata,floatb);};voidpoint::set_poi

nt(floata=0,floatb=0){x=a;y=b;}floatpoint::read_x(void){returnx;}floatpoint::read_y(void){returny;}voidpoint::move(floata,f

loatb){x+=a;y+=b;}面向对象程序设计信息科学与工程学院高级语言程序设计教学课件21第一节类和对象的基本概念3、类的测试将类的定义放在头文件hpoint.h中。再在main()测试。#include<iostream.h>#

include"hpoint.h"voidmain(void){pointp1;p1.set_point(20,30);cout<<"x="<<p1.read_x()<<endl;cout<<"y="<<p1.read_y()<<endl;p1.m

ove(5,5);cout<<"x="<<p1.read_x()<<endl;cout<<"y="<<p1.read_y()<<endl;}面向对象程序设计信息科学与工程学院高级语言程序设计教学课件22第一节

类和对象的基本概念说明通常，当成员函数代码量较大时，在类外定义成员函数。在定义成员函数以前一定要加上类名，类名与函数名间一定要用“::”；成员函数中，应给出形参名，当无形参时，通常应加上void；成员函数的返回类型，与函数原型中的返回类型必须相同。成员函数

与普通函数一样，可以设置参数的默认值面向对象程序设计信息科学与工程学院高级语言程序设计教学课件23第一节类和对象的基本概念㈡在类内部定义：将成员函数定义为内置函数1、隐式定义：直接将函数直接定义在类的内部。如：classpoint{privat

e:floatx,y;public:voidset_point(floata,floatb){x=a;y=b;}floatread_x(){returnx;}floatread_y(){returny;}voidmove(floata,floatb){x+=a;y

+=b;}}；面向对象程序设计信息科学与工程学院高级语言程序设计教学课件24第一节类和对象的基本概念2、显式定义显示定义是指在定义内置函数时，仍将函数放在类定义体之外，但为了使之能起到内置函数的作用，在函数定义前加上inline。

如：面向对象程序设计信息科学与工程学院高级语言程序设计教学课件25第一节类和对象的基本概念classpoint{private:floatx,y;public:voidset_point(floata,floatb

);floatread_x(void);floatread_y(void);voidmove(floata,floatb);};inlinevoidpoint::set_point(floata,floatb){x=a;y=b;}inlinefloat

point::read_x(void){returnx;}inlinefloatpoint::read_y(void){returny;}inlinevoidpoint::move(floata,floatb){x+=a;y

+=b;}面向对象程序设计信息科学与工程学院高级语言程序设计教学课件26第一节类和对象的基本概念四、对象的定义及引用㈠类与对象的关系1、面向对象程序设计概念（第一章）类是具有相同性质和功能的对象的抽象对象是类的实例。2、C++

面向对象程序设计语言类是将具有相同数据成员、成员函数的操作对象的概括（或抽象）——是对象的模板。对象是类的实例（具体化）——类变量。面向对象程序设计信息科学与工程学院高级语言程序设计教学课件27第一节类和对象的

基本概念㈡对象的定义：与定义结构体变量相同1、在声明（定义）类的同时定义对象（类变量）如：classpoint{private:floatx,y;public:voidsetpoint(floata,floatb

);floatgetx(void);floatgety(void);}op1,op2;但通常不采用此种方法——为什么？——类的定义通常是独立的，直接定义对象为全局对象面向对象程序设计信息科学与工程学院高级语言程序设计教学课件28第一节类和对象的基本概念2、先定义类再定义对象格式

：类名对象名表如：pointop1,op2;说明：在定义类时，计算机并不给类分配存储空间，只有定义了对象后，计算机才为对象分配存储空间；在定义类时定义的对象为全局对象——它并非在函数中定义；通常用第二种方法定义类对象——定义为局部类对象。面向对象程序设计信息科学与工程学院高

级语言程序设计教学课件29第一节类和对象的基本概念㈢对象的使用对象的使用与结构体变量的使用相同。1、数据成员的使用格式：对象名.数据成员名2、成员函数的使用格式：对象名.成员函数名（实参表）或：对象名.类名::成员函数名（实参表）例【3.5】用p

oint类求任意二个点之间的距离。分析程序面向对象程序设计信息科学与工程学院高级语言程序设计教学课件30第一节类和对象的基本概念#include<iostream.h>#include<math.h>#include"hp

oint.h"voidmain(void){pointp1,p2;floatx1,x2,y1,y2,dx,dy,s;cout<<"x1=";cin>>x1;cout<<"y1=";cin>>y1;cout<<"x2=";cin>>x2;cout<

<"y2=";cin>>y2;p1.set_point(x1,y1);p2.set_point(x2,y2);dx=p2.read_x()-p1.read_x();dy=p2.read_y()-p1.read_y();s=sqrt(dx*dx+dy*dy)

;cout<<"两点间的距离为："<<s<<endl;}面向对象程序设计信息科学与工程学院高级语言程序设计教学课件31第一节类和对象的基本概念3、说明私有成员不能在类的外部被使用——私有数据成员只能通过公有成员函数使用—

—数据的封装性；可以定义指向对象的指针来使用对象——对象指针访问其成员时用操作符“->”；可以定义对象的引用对象。例【3.6】分析程序的运行结果。面向对象程序设计信息科学与工程学院高级语言程序设计教学课件32第一节类和对象的基本概念#include<i

ostream.h>#include"hpoint.h"voidmain(void){pointp1,*p;point&p2=p1;p1.set_point(20,30);cout<<"x="<<p1.read_x();cout<<"y="<<p1.

read_y()<<endl;cout<<"x="<<p2.read_x();cout<<"y="<<p2.read_y()<<endl;p2.move(5,5);p=&p1;cout<<"x="<<p->re

ad_x();cout<<"y="<<p->read_y()<<endl;}面向对象程序设计信息科学与工程学院高级语言程序设计教学课件33第一节类和对象的基本概念㈣对象赋值语句对象赋值：用赋值表达式将一个对象赋值给另一个变量。

对象赋值的作用：是将“=”右边对象中的成员逐一赋值左边的对象——亦称为对象的拷贝。说明：在使用对象赋值语句时，两个对象必须是相同的类；对象赋值后，二个对象仍是分离的，当改变某一对象成员的值时，另一对象不

会因此而改变；对象赋值是一种浅拷贝：在一般情况下，对象赋值是成功的，但当类中存在指针时，可能会产生错误。例【3.7】分析程序的运行结果。面向对象程序设计信息科学与工程学院高级语言程序设计教学课件34第一节类和对象的基本概

念#include<iostream.h>#include"hpoint.h"voidmain(void){pointp1,p2;p1.set_point(20,30);p2=p1;cout<<"p1:x="<<p1.read_x();cout<<"y="<<p1.read_y()<

<endl;cout<<"p2:x="<<p2.read_x();cout<<"y="<<p2.read_y()<<endl;p1.move(5,5);cout<<"p1:x="<<p1.read_x();cout

<<"y="<<p1.read_y()<<endl;cout<<"p2:x="<<p2.read_x();cout<<"y="<<p2.read_y()<<endl;}面向对象程序设计信息科学与工程学院高级语言程序设计教学课件35第一节类和对象的基本概念四、类的作用域1、类的作用域：是指

在类定义时“{”与“}”之间所形成的作用域。2、说明：一个类的所有成员都在该类的作用域内；在类的内部，成员函数可以不受限制地使用所有数据成员（直呼其名）或成员函数；在类的作用域外，只能引用类的公有成员（通常为成员函数），不能引用私有成员——私有成

员只能通过公有成员访问。面向对象程序设计信息科学与工程学院高级语言程序设计教学课件36第二节对象的初始化—构造函数与析构函数在定义一个类对象时，计算机将给该对象分配相应的存储单元，同时进行必要的初始化——由构造函数完成——用户提供或由系统提供。当撤销类对象时，通常应释放

内存空间，并做一些收尾工作——由析构函数完成——由用户定义或系统提供。一、构造函数㈠构造函数的概念观察Date类的成员函数voidset_date(inty=2000,intm=1,intd=1){year=y;month=m;day=d;}——作用是

为私有数据成员year、month、day赋值——即：通过调用对象成员函数为对象的数据成员赋值；面向对象程序设计信息科学与工程学院高级语言程序设计教学课件37第二节对象的初始化—构造函数与析构函数观察Ｐoint类的成员函数void

set_point(floata,floatb){x=a;y=b;}——该函数的作用是为私有数据成员x、y赋值——即：通过调用对象成员函数为对象的数据成员赋值；结论：通常每个类都应至少提供一个函数为类中的数据成员赋值。问题：基本类

型的变量可以在定义时赋初值，定义对象时是否可以赋初值——即：在定义对象时直接给数据成员赋初值？面向对象程序设计信息科学与工程学院高级语言程序设计教学课件38第二节对象的初始化—构造函数与析构函数解决办法：将上述函数分

别改为以下形式即可：Date类：Date(inty=2000,intm=1,intd=1){year=y;month=m;day=d;}在定义类时可直接给Date对象赋初值。如：Dateda1(2004,5,1);Poi

nt类:Point(floata,floatb){x=a;y=b;}在定义类时可直接给Date对象赋初值。如：Pointp1(10.0,15.5);——即函数名与类名相同（无返回值类型）——构造函数。面向

对象程序设计信息科学与工程学院高级语言程序设计教学课件39第二节对象的初始化—构造函数与析构函数例【3.８】将例【3.３】用构造函数实现。１、类的定义（保存在hdate.h文件中）：面向对象程序设计信息科学与工程学院高级语言程序设计教学课件40第二节对象的初始化—构造函数与析构函数cla

ssDate{private:intyear,month,day;public:Date(inty=2000,intm=1,intd=1){year=y;month=m;day=d;}intisleapyear(void);voidprintdate(void){cout<<year<<'-'<

<month<<'-'<<day<<endl;}};intDate::isleapyear(void){intp;p=(year%4==0&&year%100!=0)||(year%400==0);returnp;}面向对象程序设计信息科学与工程学院高级语言程序设计教学课件41第二节对

象的初始化—构造函数与析构函数２、类的测试(主函数)#include<iostream.h>#include"hdate.h"voidmain(void){Dateda1(2004,5,1),da2(2006,10,1);da1.printdate();da2.printdate

();cout<<"2004year";if(da1.isleapyear())cout<<"isaleapyear."<<endl;elsecout<<"isnotaleapyear."<<endl;cout<<"2006year";if(da2.isleapyear())cout<<"isa

leapyear."<<endl;elsecout<<"isnotaleapyear."<<endl;}面向对象程序设计信息科学与工程学院高级语言程序设计教学课件42第二节对象的初始化—构造函数与析构函数㈡构造函数的定义格式：类

名（形参表）；性质：构造函数的名字必须与类名相同；构造函数的形参可以是任意数据类型，但不能有返回值类型；定义对象时，编译系统会自动调用构造函数。例【3.9】定义对象时自动调用构造函数举例——运行程序，观察程序的输出结果。面向对象程序设计信息科学与工程学院高级语言程序

设计教学课件43第二节对象的初始化—构造函数与析构函数#include<iostream.h>classmyclass{public:myclass(){cout<<"constructing"<<e

ndl;}};voidmain(){myclassA;}main()函数中，只定义了一个对象，但直接调用了构造函数——构造函数是在定义对象时自动执行的。面向对象程序设计信息科学与工程学院高级语言程序设计教学课件44第二节对象的初始化—构造函数与析构函数㈡构造函数的调用构造函数的调用是在定义对象时

调用的。格式：类名对象名（实参表）或：类名对象名=构造函数名（实参表）例【3.10】用构造函数实现对复数类（complex）对象的初始化。1、分析2、类的定义定义复数类complex并将其存入hcomplex.h中面向对象程序设计信息科学与工程学院高级

语言程序设计教学课件45第二节对象的初始化—构造函数与析构函数classcomplex{private:doublereal;doubleimag;public:complex(doubler,doublei){real=r;imag=i;}doublerealcomplex(void){r

eturnreal;}doubleimagcomplex(void){returnimag;}doubleabscomplex(void){doublet;t=sqrt(real*real+imag*imag);retur

nt;}};面向对象程序设计信息科学与工程学院高级语言程序设计教学课件46第二节对象的初始化—构造函数与析构函数#include<iostream.h>#include<math.h>#include"hcomplex.h"voidmain(void){complexA(

3.0,4.0);cout<<"realofcomplexA="<<A.realcomplex();cout<<endl;cout<<"imagofcomplexA="<<A.imagcomplex();cout<<endl;cout<<"absofcomplexA="<<A.

abscomplex();cout<<endl;}3、测试:在main()函数定义complex对象并初始化面向对象程序设计信息科学与工程学院高级语言程序设计教学课件47第二节对象的初始化—构造函数与析构函数#include<iostream.h>#include<math.h>#in

clude"hcomplex.h"voidmain(void){complexA=complex(3.0,4.0);cout<<"realofcomplexA="<<A.realcomplex();cout<<endl;cou

t<<"imagofcomplexA="<<A.imagcomplex();cout<<endl;cout<<"absofcomplexA="<<A.abscomplex();cout<<endl;}可将其改为：

面向对象程序设计信息科学与工程学院高级语言程序设计教学课件48第二节对象的初始化—构造函数与析构函数㈢说明构造函数必须与类同名；构造函数没有返回值；但构造函数前不能加void类型符（其他没有返回值的成员函数必须加

类型符void）；在实际应用中，在定义每个类时都应定义一至多个构造函数(重载)，以对各数据成员进行初始化；如果不给出构造函数，系统将自定义一个构造函数；构造函数可以不带任何参数；构造函数可以用初始化

表对参数进行初始化；如：面向对象程序设计信息科学与工程学院高级语言程序设计教学课件49第二节对象的初始化—构造函数与析构函数classA{inti;charj;floatf;public:A(intI,charJ,floatF){i=I;j=J;f=F;}}；classA

{inti;charj;floatf;public:A(intI,charJ,floatF)：i(I),j(J),f(F){}}；可改为：面向对象程序设计信息科学与工程学院高级语言程序设计教学课件50第二节对象的初始化—构造函数与析构函数如果数

据成员为数组，必须用赋值的方式。如：classA{inti;charj;floatf;charname[20];public:A(intI,charJ,floatF,charN[])：i(I),j(J),f(F){st

rcpy(name,N);}}；面向对象程序设计信息科学与工程学院高级语言程序设计教学课件51第二节对象的初始化—构造函数与析构函数对于没有定义构造函数的类，其公有数据成员要以用初始值表进行初始化。如：#includ

e<iostream.h>classmyclass{public:charname[20];intno;};voidmain(void){myclassa={"chen",25};cout<<a.name<<""<<a.no

<<endl;}面向对象程序设计信息科学与工程学院高级语言程序设计教学课件52第二节对象的初始化—构造函数与析构函数构造函数不能单独调用。如：complexA;A=complex(3.0,4.0);——构造函数错误的调用方法。思考：构造函数能否取代为对象提供值的函

数（如：set_date(inty,intm,intd))?二、缺省参数的构造函数在实际应用中，有些构造函数的参数值通常是不变的，只是在一些特殊情况下才需改变其值——可定义带缺省参数的构造函数。例【3.11】分析程序的输出结果面向对象

程序设计信息科学与工程学院高级语言程序设计教学课件53第二节对象的初始化—构造函数与析构函数#include<iostream.h>#include<math.h>classcomplex{private:doublereal;doubleimag;public:comp

lex(doubler=0.0,doublei=0.0){real=r;imag=i;}doubleabscomplex(){doublet;t=sqrt(real*real+imag*imag);returnt;}};面向对象程序设计信息科学与工程学院高级语言程序设计教学课件54第二节对象的

初始化—构造函数与析构函数voidmain(){complexA(3.0,4.0);complexB(3.0);complexC;cout<<"absofcomplexA="<<A.abscomplex();cout<<endl;cout<<"absofcomplexB=

"<<B.abscomplex();cout<<endl;cout<<"absofcomplexC="<<C.abscomplex();cout<<endl;}absofcomplexA=5absofcomplexB=3absofcomplexC=

0面向对象程序设计信息科学与工程学院高级语言程序设计教学课件55第二节对象的初始化—构造函数与析构函数三、析构函数㈠析构函数及作用1、析构函数析构函数也是一种特殊的成员函数，执行的是与构造函数相反的操作——通常用作执行一些清理任务（如释放对象所占用的内存等）。2、析构函数的特点析构函数与

构造函数的名字相同，但在其前面加上“~”；析构函数没有参数，也没有返回值，不能重载——一个类中只能有一个析构函数；当拆销对象时，自动调用析构函数。面向对象程序设计信息科学与工程学院高级语言程序设计教学课件56第二节对象的初始化—构造函数与析构函数例【3.12】先将“hcomp

lex.h”头文件中的内容改为以下程序，并以hhcomplex.h”存盘。面向对象程序设计信息科学与工程学院高级语言程序设计教学课件57第二节对象的初始化—构造函数与析构函数classcomplex{private:doub

lereal;doubleimag;public:complex(doubler,doublei){real=r;imag=i;cout<<"constructing..."<<endl;}~complex(void){cout<<"destructi

ng..."<<endl;}doublerealcomplex(){returnreal;}doubleimagcomplex(){returnimag;}doubleabscomplex(){doublet;t=sqrt(real*real+imag*imag)

;returnt;}};面向对象程序设计信息科学与工程学院高级语言程序设计教学课件58第二节对象的初始化—构造函数与析构函数用以下主函数测试析构函数的调用：#include<iostream.h>#include<math.h>#include"hhcomplex.

h"voidmain(){complexA(3.0,4.0);cout<<"absofcomplexA="cout<<A.abscomplex()<<endl;}结论：析构函数是在对象撤销时自动调用的运行程序的输出结果为：constructing…abs

ofcomplexA=5destructing…面向对象程序设计信息科学与工程学院高级语言程序设计教学课件59第二节对象的初始化—构造函数与析构函数㈡说明每个类必须有一个析构函数，如果未定义析构函数，则系统自定

义一个析构函数；对于大多数类而言，缺省的析构函数已够用，但有时需进行内部处理，则需要显示定义析构函数。例【3.13】显示定义析构函数举例面向对象程序设计信息科学与工程学院高级语言程序设计教学课件60第二节对象的初始化—构造函数与析

构函数#include<iostream>#include<string.h>usingnamespacestd;classstring_data{private:char*str;public:string_d

ata(char*s);~string_data(void);char*get_info(void){returnstr;}};面向对象程序设计信息科学与工程学院高级语言程序设计教学课件61第二节对象的初始化—构造函数与析构函数s

tring_data::string_data(char*s){cout<<"constructing:为字符串分配内存";cout<<endl;str=newchar[strlen(s)+1];strcpy(str,s);}string_data::~string_data(void

){deletestr;cout<<"destructing:释放字符串占用内存";cout<<endl;}面向对象程序设计信息科学与工程学院高级语言程序设计教学课件62第二节对象的初始化—构造函数与析构函数voidmain(void){string_datastr1("teacher");c

out<<str1.get_info()<<endl;}结论：当在构造函数中用new动态分配内存空间时，应显式定义析构函数，用delete释放已分配的内存空间。面向对象程序设计信息科学与工程学院高级语言程序设计教学课件63第二节对象的初始化—构造函数与析构函数四、重载构造函数与一般的成员函

数一样，构造函数也可以重载。如：classA{…public:A(void);A(int);A(int,char);A(float,char);…}面向对象程序设计信息科学与工程学院高级语言程序设计教学课件64第二节对象的初始化—构造函数与析构函数在main()函数中可分别调用：main

(){Ax;Ay(10);Az(10,’z’);Aw(5.5,’W’);…}例【3.14】分析下列程序，熟悉构造函数的重载。面向对象程序设计信息科学与工程学院高级语言程序设计教学课件65第二节对象的初始化—构造函数与析构函数#include<iostream.h>classtime

r{private:intseconds;public:timer(){seconds=0;}timer(inti){seconds=i;}timer(intmin,intsec){seconds=min*60+sec;}intgettime

(){returnseconds;}};面向对象程序设计信息科学与工程学院高级语言程序设计教学课件66第二节对象的初始化—构造函数与析构函数voidmain(void){timera,b(10),c(1,10);cout<<"second

s1="<<a.gettime()<<endl;cout<<"seconds2="<<b.gettime()<<endl;cout<<"seconds3="<<c.gettime()<<endl;}面向对象程序设计信息科学与工程学院高级语言程

序设计教学课件67第二节对象的初始化—构造函数与析构函数五、拷贝构造函数（复制构造函数）㈠什么是拷贝构造函数例【3.15】分析程序的结果#include<iostream.h>#include"hpoint.h"voidmain(void){pointp1;p1.set_po

int(20,30);pointp2=p1,p3(p1);cout<<"p1:x="<<p1.read_x();cout<<"y="<<p1.read_y()<<endl;cout<<"p2:x="<<p2.read_x();cout<<"y=

"<<p2.read_y()<<endl;cout<<"p3:x="<<p3.read_x();cout<<"y="<<p3.read_y()<<endl;}面向对象程序设计信息科学与工程学院高级语言程序设计教学课件6

8第二节对象的初始化—构造函数与析构函数其中：p2=p1;pointp3(p1);——对象的拷贝可以把hpoint.h中的类定义改为如下形式（存放在hhpoint.h中)：面向对象程序设计信息科学与工程学院高级语言程序设计教

学课件69第二节对象的初始化—构造函数与析构函数classpoint{private:floatx,y;public:point(void)//无参构造函数{x=0;y=0;}point(floata,floatb)//构造函数重载{x=a;y=b;}point(constp

oint&ob)//拷贝构造函数{x=ob.x;y=ob.y;}voidset_point(floata,floatb);floatread_x(void);floatread_y(void);voidmove(floata,floatb);};面向对象程序设计信息

科学与工程学院高级语言程序设计教学课件70第二节对象的初始化—构造函数与析构函数voidpoint::set_point(floata,floatb){x=a;y=b;}floatpoint::read_x(void){returnx;}floatpoint::read_y(voi

d){returny;}voidpoint::move(floata,floatb){x+=a;y+=b;}其中:point(constpoint&ob){x=ob.x;y=ob.y;}——拷贝构造函数面向对象程序设计信息科学与工程学院高级语言程序设计教学课件71第二节对

象的初始化—构造函数与析构函数㈡拷贝构造函数的定义格式类名（[const]类名&对象名）{函数体}——通常为数据成员拷贝㈢默认拷贝构造函数如果不定义拷贝构造函数，系统会自定义一个拷贝构造函数，实现对数据成员的

拷贝。㈣说明拷贝构造函数无返回值，也不能有void；通常不用单独编写拷贝构造函数，直接使用默认拷贝构造函数;默认拷贝构造函数是一种浅拷贝——当在类中用new分配内存空间时，通常应编制相应的拷贝构造函数。面向对象程序设计信息科学与工程学院高级语言程序设计教学课件72第二节对象的初始化—构造

函数与析构函数例【3.16】调试程序(e316.cpp)，熟悉显式定义拷贝构造函数方法。面向对象程序设计信息科学与工程学院高级语言程序设计教学课件73第三节对象数组、对象指针及对象引用一、对象数组可以定义对象数组处理

多个对象例【3.17】利用hhpoint.h中的point类建立对象数组并分析程序的结果。#include<iostream.h>#include"hhpoint.h"voidmain(void){pointp[5];inti;for(i=0;i<5;i+

+){p[i].set_point(i+1,2*(i+1));}for(i=0;i<5;i++)cout<<p[i].read_x()<<""<<p[i].read_y()<<endl;}面向对象程序设计信息科学与工程学院高级语言程序设计教学课件74第三节对象数

组、对象指针及对象引用可以用缺省参数构造函数为对象数组赋初值。如：将上例改为：#include<iostream.h>#include"hhpoint.h"voidmain(void){pointp[5];//自动调用缺省参数构造函数inti;for(i=0;i<5;i++)cout<<

p[i].read_x()<<""<<p[i].read_y()<<endl;for(i=0;i<5;i++){p[i].set_point(i+1,2*(i+1));}for(i=0;i<5;i++)cout<<p[i].read_x()<<""<<p[i

].read_y()<<endl;}面向对象程序设计信息科学与工程学院高级语言程序设计教学课件75第三节对象数组、对象指针及对象引用二、对象指针可以使用指针引用对象或对象数组。方法：定义对象指针将指针指

向某一对象（或对象数组）用指针引用对象（或对象数组）格式：对象指针->公有成员例【3.18】分析程序的输出结果面向对象程序设计信息科学与工程学院高级语言程序设计教学课件76第三节对象数组、对象指针及对象引用#include<iostream.h>

#include"hhpoint.h"voidmain(void){pointp1(5.5,12.0),p2[5],*p;inti;p=&p1;//p指向对象p1;cout<<p->read_x()<<""<<p->read_y()<<endl;cout<<end

l;for(i=0;i<5;i++){p2[i].set_point(i+1,2*(i+1));}p=p2;//p指向对象数组p2,或改为：p=&p2[0];for(i=0;i<5;i++)cout<<p->read

_x()<<""<<p->read_y()<<endl;}面向对象程序设计信息科学与工程学院高级语言程序设计教学课件77第三节对象数组、对象指针及对象引用三、对象引用可以定义对象的引用四、this指针1、th

is指针C++提供了一个特殊的对象指针——this指针;this指针为成员函数所属对象的指针,指向对象的地址;this指针是一种隐含指针，隐含于每个类的成员函数中,即调用某成员函数时，都将自动产生一个this指针。this指针可以隐式调用——即在

类内部直呼其名（前面介绍的所有例子）——通常均采用此种方法。面向对象程序设计信息科学与工程学院高级语言程序设计教学课件78第三节对象数组、对象指针及对象引用2、显式调用this指针格式：this->成员名例【3.19】将hhpoin

t.h文件中的point类的定义改为：面向对象程序设计信息科学与工程学院高级语言程序设计教学课件79第三节对象数组、对象指针及对象引用classpoint{private:floatx,y;public:point(void)//无参构造函数{this->x=0;th

is->y=0;}point(floata,floatb)//构造函数重载{this->x=a;this->y=b;}point(constpoint&ob)//拷贝构造函数{this->x=ob.x;this->y=ob.y;}v

oidset_point(floata,floatb);floatread_x(void);floatread_y(void);voidmove(floata,floatb);};面向对象程序设计信息科学与工程学院高级语言程序设计教学课件80第三节对象数组、对象

指针及对象引用voidpoint::set_point(floata,floatb){this->x=a;this->y=b;}floatpoint::read_x(void){returnthis->x;}f

loatpoint::read_y(void){returnthis->y;}voidpoint::move(floata,floatb){this->x+=a;this->y+=b;}注意：this指针是系统自定义的，用户不能再定义面向对象程序设计信息科学与工程学院高级语言程

序设计教学课件81第四节向函数传递对象在C++中，可以用对象作为函数的参数——形参或实参。主要有以下形式：形参、实参均为对象——传值调用；形参为对象指针，实参为对象指针或对象地址——传址调用；形

参为对象引用，实参为对象——传址调用；形参、实参为对象指针或对象数组——传址调用。1、形参、实参均为对象——传值调用例【3.20】分析下列程序的输出结果面向对象程序设计信息科学与工程学院高级语言程序设计教学课件82第四节向函数传递对象#include<iostream.h>

#include"hhpoint.h"voidf1(pointp){p.move(5.5,10.5);cout<<p.read_x()<<""<<p.read_y()<<endl;}voidmain(){pointp1(10.2,20.8);cout<<p1.read_x()

<<""<<p1.read_y()<<endl;f1(p1);//调用f1:将实参对象p1传递给形参pcout<<p1.read_x()<<""<<p1.read_y()<<endl;}结果：10.220.815.731.310.220.8面向对象程序设计信息科学与工程学院高级语言程序设

计教学课件83第四节向函数传递对象2、形参为对象指针，实参为对象指针或对象地址例【3.21】分析下列程序的输出结果#include<iostream.h>#include"hhpoint.h"voidf2(point*p){p->move(5.5,10.5);cout<<p->read_x()<

<""<<p->read_y()<<endl;}voidmain(){pointp1(10.2,20.8);cout<<p1.read_x()<<""<<p1.read_y()<<endl;f2(&p1);//调用f2:将对象p1的地址传递给形参pc

out<<p1.read_x()<<""<<p1.read_y()<<endl;}面向对象程序设计信息科学与工程学院高级语言程序设计教学课件84第四节向函数传递对象3、形参为对象引用，实参为对象例【3.22】分析下列程序的输出结果#include<ios

tream.h>#include"hhpoint.h"voidf3(point&p){p.move(5.5,10.5);cout<<p.read_x()<<""<<p.read_y()<<endl;}voidmain(){pointp1(10.2,

20.8);cout<<p1.read_x()<<""<<p1.read_y()<<endl;f3(p1);//调用f3:将对象传递给引用对象pcout<<p1.read_x()<<""<<p1.read_y()<<endl;}面向对象程序设计信息科学与工程学院高级语言

程序设计教学课件85第四节向函数传递对象4、形参、实参为对象指针或对象数组例【3.23】定义处理3科成绩及平均成绩的类，用动态数组类实现n个学生的成绩处理——成绩的输入、输出、计算n个学生的平均成绩均用

普通函数实现（程序在e323.cpp中）例【3.24】综合举例。将上例改为处理任意个学生的任意科（不超过10科成绩），要求：成绩的输入成绩的输出n个学生的平均成绩按平均由高到低成绩排序后输出（将成绩类的定义放在hscore.h中）面向对象程

序设计信息科学与工程学院高级语言程序设计教学课件86第四节向函数传递对象1、类的定义（定义类并将其放在hscore.h文件中）数据成员（私有）：sc[M]——成绩，aver——平均成绩，m——科数；成员函数（公有）：s

core(void)——对sc[M]、aver置0；score(floatx[],intn)——成绩初始化（赋值）；voidset_score(floatx[],intn)——成绩赋值；floatget_score(in

ti)——得到第i科成绩；floatget_aver(void)——得到平均成绩；voidprint_score(void);——输出成绩及平均成绩。面向对象程序设计信息科学与工程学院高级语言程序设计教学课件87第四节向函数传递对象constin

tM=10;classscore{private:floatsc[M],aver;intm;public:score(void);//无参构造函数score(floatx[],intn);//构造函数重载：初始化成绩voidse

t_score(floatx[],intn);//提供成绩floatget_score(inti)//得到第i科成绩{returnsc[i];}floatget_aver(void)//得到平均成绩{returnaver;}voidprint_sco

re(void);};面向对象程序设计信息科学与工程学院高级语言程序设计教学课件88第四节向函数传递对象score::score(void)//无参构造函数{inti;m=M;for(i=0;i<m;i++)sc[i]=0;aver=0;}score::score(flo

atx[],intn)//构造函数重载：初始化成绩{inti;floatsum=0;m=n;for(i=0;i<m;i++){sc[i]=x[i];sum+=sc[i];}aver=sum/m;}面向对象程序设计信息科学与工程学院高级语言程序设计教学课件8

9第四节向函数传递对象voidscore::set_score(floatx[],intn)//提供成绩{inti;floatsum=0;m=n;for(i=0;i<m;i++){sc[i]=x[i]

;sum+=sc[i];}aver=sum/m;}voidscore::print_score(void)//输出成绩、平均成绩{inti;for(i=0;i<m;i++)cout<<""<<sc[i];cout<<""<<aver<<endl;}面向对象程序设计信息科学与工程学院高级语言程序

设计教学课件90第四节向函数传递对象2、成绩处理——用动态数组处理任意个学生的成绩：voidinput(score*p,intn,intm)——n个学生m科成绩的输入voidprint(score*p,intn,intm)—

—n个学生m科成绩的输出score&average(score*p,intn,intm)——m科成绩及平均成绩的平均成绩计算voidsort(score*p,intn,intm)——n个学生m科成绩按平均成绩排序面向对象程序设计信息科学与工程学院高级语言程序设计教学课件91第

四节向函数传递对象voidmain(void){intn,m;cout<<"学生人数：";cin>>n;cout<<"考试科数：";cin>>m;score*p,aver;p=newscore[n];//动态分配内存单元——动态数组if(p==NULL){

cout<<"内存分配失败"<<endl;return;}input(p,n,m);//调用输入成绩函数print(p,n,m);//调用输出成绩函数aver=average(p,n,m);//调用平均值计算函数aver.pri

nt_score();sort(p,n,m);print(p,n,m);//调用输出成绩函数delete[]p;//释放内存}面向对象程序设计信息科学与工程学院高级语言程序设计教学课件92第四节向函数传递对象void

input(score*p,intn,intm){inti,j;floatx[M];for(i=0;i<n;i++){cout<<"第"<<i+1<<"个学生成绩："<<endl;for(j=0;j<m;j++){cout<<"第"<<j+1<<"科成绩：";cin>>x[j];}p[i].set

_score(x,m);}}voidprint(score*p,intn,intm){inti;for(i=0;i<n;i++)p[i].print_score();}面向对象程序设计信息科学与工程学院

高级语言程序设计教学课件93第四节向函数传递对象//求平均值score&average(score*p,intn,intm)//用返回引用的方法{inti,j;floats[M]={0};staticscoreaver;//返回的对象为静态的for(j=0;j

<m;j++){for(i=0;i<n;i++)s[j]=s[j]+p[i].get_score(j);s[j]=s[j]/n;}aver.set_score(s,n);returnaver;}面向对象程序设计信息科学与工程学院

高级语言程序设计教学课件94第四节向函数传递对象//选择法排序voidsort(score*p,intn,intm){scoret;floata;inti,j,k;for(i=0;i<n-1;i++){a=p[i].ge

t_aver();k=i;for(j=i+1;j<n;j++)if(a<p[j].get_aver()){a=p[j].get_aver();k=j;}if(k!=i){t=p[i];p[i]=p[k];p[k]=t;}}}面向对象程序设计信息科学

与工程学院高级语言程序设计教学课件95第五节静态成员静态成员分为静态数据成员及静态成员函数。一、静态数据成员1、静态数据成员的定义（类中定义）格式：static类型数据成员名表；2、静态成员的作用静态成员在一

个类中只有一个拷贝——它不属于某一个对象，而属于一个类（属于所有对象）——无论建立多少个对象，都共享静态成员——是连接各个对象的桥梁；静态数据成员主要用于各个对象公用数据。如：总数的统计（如窗口的打开次数等）、平均数等。面向对象程序设计信息

科学与工程学院高级语言程序设计教学课件96第五节静态成员（教材①P132-139）例【3.25】分析程序的输出结果。#include<iostream.h>classcounter{private:staticintcount

;//count为静态数据成员charch;//普通数据成员public:counter(charc)//构造函数{count++;ch=c;}voidprint_counter(void){cout<<ch<<":"<<count<

<endl;}~counter(void)//析构函数{count--;}};面向对象程序设计信息科学与工程学院高级语言程序设计教学课件97第五节静态成员intcounter::count=100;//静态数据成员赋初值voidmain(void){cou

nterc1('A');c1.print_counter();cout<<endl;counterc2('B');c1.print_counter();c2.print_counter();cout<<endl;counterc3('C');c1

.print_counter();c2.print_counter();c3.print_counter();}面向对象程序设计信息科学与工程学院高级语言程序设计教学课件98第五节静态成员3、说明静态数据成员可以说明为公有的、私有的或保

护的，说明为公有的可直接访问：类名::静态成员名私有或保护静态数据成员只能通过公有成员函数访问静态数据成员不能在类中进行初始化（不分配内存空间），在程序开始运行时即生成（不依赖任何对象），必须在任何函数之外进行初始化操作；格式：类型类名::静态数据成员=初值；静态成员

不同于全局变量——封装在类内部——使用静态数据成员取代全局变量，使数据更为安全；静态数据成员与静态变量是两个完全不同的概念。面向对象程序设计信息科学与工程学院高级语言程序设计教学课件99第五节静态成员4、结论：当在类中需要共享某一数据成员时应定义为静态数据成员——

如：记录建立对象的个数；在窗口打开时记录打开的次数等。二、静态成员函数1、为什么提出静态成员函数在类中使用静态数据成员后，只要某一个对象改变了其值，整个类的对象相应的静态数据成员的值均改变——强耦合（？）有效解决办法——静态成员函数—

—用于访问静态数据成员2、静态成员函数的定义在成员函数名前加上static。面向对象程序设计信息科学与工程学院高级语言程序设计教学课件100第五节静态成员例【3.26】分析程序的输出结果，熟悉静态成员函数的定义及访问静态数据成员的方法。（原文件e326.cpp）3

、说明：静态成员函数可以在类内部定义（必须在上static），也可在类外定义——即在类内部声明，在类外定义——类外定义时方法与普通成员函数相同。静态成员函数属于一个类，可用类名调用格式：类名::静态成员函数名（实参表）；如：simple::sum1

(&ob1);simple::sum1(ob2);静态成员可以用对象调用格式：对象名.静态成员函数名（实参表）；如：ob1.sum1(&ob1);ob2.sum1(ob2);面向对象程序设计信息科学与工程学院高级语言程序

设计教学课件101第五节静态成员静态成员函数由于无this指针（this指针属于某一对象，静态成员属于一个类），只能访问静态数据成员，不能访问普通数据成员——静态成员函数专门用来访问静态数据成员。例：将上例改为:定义静态成员函数sum——用于专门访问静态数据成员。原文件e326

1.cpp）注意：普通成员函数既可以访问普通数据成员，也可以访问静态数据成员。结论：当在类中定义有静态数据成员时，通常应定义静态成员函数来访问静态数据成员。面向对象程序设计信息科学与工程学院高级语言程序设计教学课件102第六节常量对象及常量成员在C++中可以用c

onst定义常量对象（常对象）、常量成员函数（常成员函数）、常量数据成员（常数据成员）一、常量对象定义格式：类名const对象名表；或：const类名对象名表例【3.27】调试程序，熟悉常对象与普通对象的不同。（源文件：e327.cpp）面向对象程序设计信息科学与工程学院

高级语言程序设计教学课件103第六节常量对象及常量成员通过调试程序，可以得出以下结论：常量对象不能访问普通成员函数（公有成员）；常量对象可以访问常量成员函数（公有成员）；常量对象的数据成员的值不能改变二、常量成员函数1、常量成

员函数的定义格式在类中定义：格式：返回类型成员函数名(参数表)const{函数体}面向对象程序设计信息科学与工程学院高级语言程序设计教学课件104第六节常量对象及常量成员在类外定义先声明：返回类型成员函数名(参数表)const；格式：返回类型类名::成员函数名(参数表)const{函数体}2、

说明：常量对象只能调用其常量成员函数，不能调用普通成员函数；普通对象既可调用普通成员函数，也可以调用常量成员函数普通成员函数可以访问本类的常量成员函数常量成员函数不能访问本类的普通成员函数面向对象程序设计信息科学与工程学院高级语言程序设计教学课件105第六节常

量对象及常量成员常量成员函数与普通成员函数同名时，构成函数的重载——参数类型和个数可以相同，用const加以区分。三、常量数据成员在类中定义数据成员时，可以定义为常量1、定义格式const数据类型成员名或数据类型const

成员名例【3.28】分析P144例3.21中的程序，熟悉常量数据成员及应用面向对象程序设计信息科学与工程学院高级语言程序设计教学课件106第六节常量对象及常量成员2、说明常量数据成员是指在一个对象中该数据成员的值不能改变；同普通数据成员一样，常量数据成员隶属于某一对象（

与静态数据成员的差异）；常量数据成员必须在构造函数中通过初始化列表进行初始化。如例中构造函数：Airliner(char*str,inta,intb):maxpassenger(a)——用a的值初始化常量数据成员maxpassenger

。面向对象程序设计信息科学与工程学院高级语言程序设计教学课件107第七节友元一、为什么要采用友元在类中定义的私有成员，只能通过公有成员访问——数据的封装与隐藏。优点：提高软件的可靠性、可重用性、可维护性不足：增加了程序运行时函数的调用开销——当成员函

数调用很频繁时，将导致执行效率的降低——增加程序的运行时间。如例【3.24】中的成绩类对象数组的排序：voidsort(score*p,intn,intm){scoret;floata;inti,j,k;fo

r(i=0;i<n-1;i++){a=p[i].get_aver();k=i;for(j=i+1;j<n;j++)if(a<p[j].get_aver()){a=p[j].get_aver();k=j;}

if(k!=i){t=p[i];p[i]=p[k];p[k]=t;}}}假定n=5,外循环执行4次，1-4次外循环内循环分别执行4、3、2、1次，共执行10次，每一次外循环调用1次get_aver()函数，每一次内循环调用2次get_ave

r()函数（共25次）——n越大调用次数越多。面向对象程序设计信息科学与工程学院高级语言程序设计教学课件108第七节友元二、友元函数1、友元函数的定义:在函数前friend例【3.29】分析程序的运行结果，熟悉友元函数的定义及应用（源程序文件：e329.cpp）面向对象程序设计信息科学与

工程学院高级语言程序设计教学课件109第七节友元#include<iostream.h>#include<string.h>classgirl{private:char*name;intage;pub

lic:girl(char*na,intn){name=newchar[strlen(na)+1];strcpy(name,na);age=n;}~girl(void){deletename;}//释

放new分配的内存面向对象程序设计信息科学与工程学院高级语言程序设计教学课件110第七节友元char*get_name(void){returnname;}intget_age(void){returnage;}voidprint_girl(void);friendvoiddisp(girl&g)

;//声明disp为友元函数};voidgirl::print_girl(void){cout<<"姓名:"<<name;cout<<"年龄:"<<age<<endl;}面向对象程序设计信息科学与工程学院高级语言程序设计教学课件111第七节友元vo

iddisp(girl&g)//定义友元函数：不是类的成员不需要作用域运算符{cout<<"姓名:"<<g.name;cout<<"年龄:"<<g.age<<endl;}voidmain(void){girlg1(“

李小丫”,12)；girlg2(“王永兰”,15);girlg3("赵梦美",13);cout<<"姓名:"<<g1.get_name();cout<<"年龄:"<<g1.get_age()<<endl;g2.print_girl();dis

p(g3);//调用友元函数：与普通函数调用相同}面向对象程序设计信息科学与工程学院高级语言程序设计教学课件112第七节友元2、说明友元函数不是类的成员函数——除非确因成员函数频繁，一般不要成义友元函数（与面

向对象思想矛盾）；友元函数主要用于运算符的重载友元函数可以访问对象的私有成员，只是在类中声明时加上friend，由于不是成员函数，定义时不必在函数名前加上“类名::”友元函数无this指针，因此，一般应带有一个入口参数——通过入口参数传递的对象名来引用

该对象的成员。当一个函数需要访问二个或以上的类时，友元函数非常有用例【3.30】分析程序的输出结果（源文件e330.cpp）面向对象程序设计信息科学与工程学院高级语言程序设计教学课件113第七节友元#in

clude<iostream.h>#include<string.h>classboy;//类boy的声明;classgirl{private:char*name;intage;public:girl(char*na,intn){name=n

ewchar[strlen(na)+1];strcpy(name,na);age=n;}~girl(void){deletename;}//释放new分配的内存friendvoiddisp(girl&

g,boy&b);//声明disp为girl类友元函数};面向对象程序设计信息科学与工程学院高级语言程序设计教学课件114第七节友元classboy{private:char*name;intage;public:boy(char*na

,intn){name=newchar[strlen(na)+1];strcpy(name,na);age=n;}~boy(void){deletename;}//释放new分配的内存friendvoiddisp(girl&g,boy&b);//声明disp

为boy类友元函数};面向对象程序设计信息科学与工程学院高级语言程序设计教学课件115第七节友元voiddisp(girl&g,boy&b)//定义友元函数：不是类的成员不需要作用域运算符{cout<

<"女孩姓名:"<<g.name;cout<<"年龄:"<<g.age<<endl;cout<<"男孩姓名:"<<b.name;cout<<"年龄:"<<b.age<<endl;}voidmain(void){girlg1("李小丫",

12);boyb1("张海兵",15);disp(g1,b1);//调用友元函数：与普通函数调用相同}面向对象程序设计信息科学与工程学院高级语言程序设计教学课件116第七节友元三、友元成员友元成员是指一个类的成员函数可以是另一个类的友友元函数——即可以通过一个类

的成员函数访问另一个类的私有成员。例【3.31】分析程序的输出结果（源文件e331.cpp）面向对象程序设计信息科学与工程学院高级语言程序设计教学课件117第七节友元#include<iostream.h>#include<string.h>classboy;//类boy的

声明;classgirl{private:char*name;intage;public:girl(char*na,intn){name=newchar[strlen(na)+1];strcpy(name,na);age=

n;}~girl(void){deletename;}//释放new分配的内存voiddisp(boy&b);//声明disp为girl类的成员函数};面向对象程序设计信息科学与工程学院高级语言程序设计教学课件118第七节友元classboy{private:

char*name;intage;public:boy(char*na,intn){name=newchar[strlen(na)+1];strcpy(name,na);age=n;}~boy(void){deletename;}//释放new分配的内存friendvoidgirl::disp(

boy&b);//声明disp为boy类的友员函数//disp既是girl的成员函数，又是boy的友元函数};面向对象程序设计信息科学与工程学院高级语言程序设计教学课件119第七节友元voidgirl:

:disp(boy&b)//定义友元函数：不是类的成员不需要作用域运算符{cout<<"女孩姓名:"<<name;cout<<"年龄:"<<age<<endl;cout<<"男孩姓名:"<<b.name;cout<<"年龄:"<

<b.age<<endl;}voidmain(void){girlg1("李小丫",12);boyb1("张海兵",15);g1.disp(b1);//调用对象g1的成员函数}面向对象程序设计信息科学与工程学院高级语言程序设计教学课件120第七节友元说明一个类的成员函数要作为另一个类

的友元函数时，必须先定义这个类（如girl类）；由于友元函数所在的类名先于类的定义出现，应先声明。四、友元类友元类是指一个类可以作为另一个类的友元——可以用友元类的成员函数访问类中的成员。例【3.32】分析程序的输出结果（源文件e

332.cpp）面向对象程序设计信息科学与工程学院高级语言程序设计教学课件121第七节友元#include<iostream.h>#include<string.h>classboy;//类boy的声明;classgirl{private:char*name;intage;publi

c:girl(char*na,intn){name=newchar[strlen(na)+1];strcpy(name,na);age=n;}~girl(void){deletename;}//释放new分配的内存voiddisp(boy&b);//声明disp为girl类

的成员函数};面向对象程序设计信息科学与工程学院高级语言程序设计教学课件122第七节友元classboy{private:char*name;intage;friendgirl;//声明girl是boy的友元类public:boy(char*na,

intn){name=newchar[strlen(na)+1];strcpy(name,na);age=n;}~boy(void){deletename;}//释放new分配的内存};面向对象程序设计信息科学与工程学院高级语言程序设计教学课件123第七节友元

voidgirl::disp(boy&b)//定义友元函数：不是类的成员不需要作用域运算符{cout<<"女孩姓名:"<<name;cout<<"年龄:"<<age<<endl;cout<<"男孩姓名:"<<b.name;cout<<"年龄:"<<b.age<<endl;

}voidmain(void){girlg1("李小丫",12);boyb1("张海兵",15);g1.disp(b1);//调用友元函数：与普通函数调用相同}面向对象程序设计信息科学与工程学院高级语言程序设计教学课件124第七节成员对象与容器类一、对象成员及容器类的概念在C++中，在

定义一个类的数据成员时，除可以是基本数据成员外，还可以是其它类的对象——称为对象成员。如：classA{…};classB{…Aa;…};如果一个类包含有对象成员，称为容器类——组合技术面向对象程序设计信息科学与工程学院高级

语言程序设计教学课件125第七节成员对象与容器类二、容器类构造函数在容器类中的构造函数，可以通过初始化表为对象成员初值。方法为：类名(参数表):成员名1(参数表1)，…,成员名n(参数表n)例【3.33】分析程序的输出结果（源文件e333.cpp）

熟悉用构造函数为对象成员赋初值。面向对象程序设计信息科学与工程学院高级语言程序设计教学课件126第七节成员对象与容器类#include<iostream.h>#include<string.h>classs

tring{private:char*str;public:string(char*s){str=newchar[strlen(s)+1];strcpy(str,s);}voidprint(void){co

ut<<str;}~string(){delete[]str;}};面向对象程序设计信息科学与工程学院高级语言程序设计教学课件127第七节成员对象与容器类classgirl{private:stringname;intage;publi

c:girl(char*st,intag):name(st){age=ag;}voidprint(void){cout<<"姓名:";name.print();cout<<"年龄:"<<age<<endl;}};voidmain(void){girlgl("张小丫",15);gl.print();

}面向对象程序设计信息科学与工程学院高级语言程序设计教学课件128第七节成员对象与容器类三、说明容器类中至少应有一个构造函数，以通过参数表为成员对象赋初值——系统不为容器类提供构造函数；创建容器类对象时，先调用对象成员所属类的构造函数，其执行顺序是对象

成员的定义顺序；释放容器类对象时，先调用容器类的析构函数，再调用对象成员的析构函数；可以用容器类对象调用对象成员所属类的公有成员函数：容器类对象成员名.对象成员所属类名::成员函数名(实参表);面向对象程序设计信息科学与工程学院高级语言程序设计教学课件129第七节成员对象与容器类例【3.3

4】定义一个date类，数据成员包括year、month、day（均为整型）；再定义一个person类，包括name（字符指针）、sex（字符数组）、birthday（为date型）。date类的定义放在“hdate.h”文件

中；person类的定义放在“hperson.h”文件中；将主函数放在e334.cpp文件中。面向对象程序设计信息科学与工程学院高级语言程序设计教学课件130第七节成员对象与容器类classdate{priva

te:intyear,month,day;public:date(void){year=1980;month=1;day=1;}date(inty,intm,intd){year=y;month=m;day=d;}intge

t_year(void){returnyear;}intget_month(void){returnmonth;}intget_day(void){returnday;}};面向对象程序设计信息科学与工程学院高级语言程序设计教学课件131第七节成员对

象与容器类#include<string.h>classperson{private:char*name;charsex[2];datebirthday;public:person(char*na,cha

r*s,inty,intm,intd):birthday(y,m,d){name=newchar[strlen(na)+1];strcpy(name,na);strcpy(sex,s);}char*get_nam

e(void){returnname;}char*get_sex(void){returnsex;}面向对象程序设计信息科学与工程学院高级语言程序设计教学课件132第七节成员对象与容器类intget_year(void){returnbirthday.get_year();}intget_mon

th(void){returnbirthday.get_month();}intget_day(void){returnbirthday.get_day();}~person(void){delete[]name;}voidprint(void);};void

person::print(void){cout<<"姓名:"<<name<<endl;cout<<"性别:"<<sex<<endl;cout<<"出生日期:"<<birthday.get_year()<<"年";cout<<birthday

.get_month()<<"月";cout<<birthday.get_day()<<"日"<<endl;}面向对象程序设计信息科学与工程学院高级语言程序设计教学课件133第七节成员对象与容器类#include<iostream.h>#include"hdate.h"#include"hper

son.h"voidmain(void){personps1("张小三","男",1985,12,15);personps2("李小丫","女",1986,3,9);ps1.print();cout<<endl;ps2.print();}面向对象程序设计信息科学与工程学院高级语言程序设计

教学课件134第八节标识符的作用域、可见性和名空间本节内容主要为自学内容。主要包括：一、标识符的作用域规则1、标识符：包括函数名、常量名、变量名、类名、对象名、成员名、语句标号等2、标识符的可见性：是指在某一区域

内是否可以访问（存取）3、标识符作用域的大小：程序级、文件级、函数级、类级、块级（复合语句内）。二、作用域的种类1、程序级：在整个程序中均可见——在某个文件中定义，在其它文件中声明（如用extern声明的外部变量)面向对象

程序设计信息科学与工程学院高级语言程序设计教学课件135第八节标识符的作用域、可见性和名空间2、文件级：从定义处开始到文件的结束（如在某一文件中定义的全局变量）3、类的作用域：即类体普通数据成员、成员函数为类作用域，类名为文件级作用域；友元不属于成员函数，为文件级作用域静态成员属于整

个类，为文件级作用域4、函数级作用域：函数中的语句标号是唯一的函数级作用域。5、块级作用域:在复合语句块内（“{”开始、“}”结束）定义的标识符。如：局部变量（自动、局部静态、寄存器变量等）面向对象程序设计信息科学与工程学院

高级语言程序设计教学课件136第八节标识符的作用域、可见性和名空间三、头文件C++程序的组织方式：1、用工程的方式——在一个工程下有多个源文件；2、用头文件四、标识符的名空间在由许多人共同开发一个大型软件时，往往用标

识符的作用域仍然不能避免标识符的重复定义——有效的解决办法：使用标识符的名空间。1、名空间的定义namespace名空间名{<名空间体>}另外，在名空间内可再定义另外的名空间面向对象程序设计信息科学与工程学院高级语言程序设计教学课件137第八节标识符的作用域、可见性和名空间2、名空间

的使用一般名空间的使用：usingnamespae名空间名;如：usenamespacestd;内存名空间的使用：usingnamespace外层名空间名::内层名空间名；面向对象程序设计信息科学与工程学院