面向对象第组

面向对象第组第一页，共四十五页，2022年，8月28日我们按照C++通常的做法，是将程序组成独立的文件。一个源程序一般至少分为三个源文件：类声明文件（.h文件）类实现文件（.cpp文件）类的使用文件（main（）所在的.cpp文件）最后利用工程来组合各个文件。先浏览下上节课时钟的例子第二页，共四十五页，2022年，8月28日例子

clock1.h类声明文件#include<iostream.h>classClock //时钟类声明{public: //外部接口

Clock（）;//默认构造函数Clock(intNewH,intNewM,intNewS);//自定义构造函数voidShowTime（）; ~Clock（）{}private: //私有数据成员

intHour,Minute,Second;};};

第三页，共四十五页，2022年，8月28日类实现文件clock1.cpp#include”clock1.h”Clock::Clock（）

//构造函数{ Hour=0; Minute=0; Second=0;}Clock::Clock(intNewH,intNewM,intNewS){ Hour=NewH; Minute=NewM; Second=NewS;}voidClock::ShowTime（）{ cout<<Hour<<":"<<Minute<<":"<<Second<<endl;}第四页，共四十五页，2022年，8月28日

类使用文件useclock1.cpp#include“clock1.h”voidmain（） //主函数{constintst=4; Clockmyclock[st]={Clock(1,2,3),Clock(),Clock(4,5,6),};//对象数组for(inti=0;i<st;i++)myclock[i].ShowTime（）;}第五页，共四十五页，2022年，8月28日运行结果：1:2:3

0:0:04:5:60:0:0第六页，共四十五页，2022年，8月28日对象数组声明：类名数组名[元素个数]；访问方法：通过下标访问数组名[下标].成员名第七页，共四十五页，2022年，8月28日

对象数组初始化数组中每一个元素对象被创建时，系统都会调用类构造函数初始化该对象。通过初始化列表赋值。例：constintst=4; clockmyclock[st]={clock(1,2,3),clock(),clock(4,5,6),};如果没有为数组元素指定显式初始值，数组元素便使用缺省值初始化（调用缺省构造函数）。第八页，共四十五页，2022年，8月28日刚才定义的时钟类中下面几种声明是否可行Clockfirst(1,2,3);

Clockfirst;Clockfirst=Clock();Clockfirst();第九页，共四十五页，2022年，8月28日C++提供了两种使用构造函数来初始化对象的方式。第一种是显式的调用构造函数：Classfirst=Class(1,2,3);

另一种方法是隐式调用构造函数：

Classfirst(1,2,3);

它与下面的显式调用等价：

Classfirst=Class(1,2,3);隐式调用默认构造函数，不需要使用圆括号。否则，Classfirst()将返回一个Class对象的函数。第十页，共四十五页，2022年，8月28日静态成员静态数据成员用关键字static声明该类的所有对象维护该成员的同一个拷贝一般在类外定义和初始化，用(::)来指明所属的类。static数据成员也必须遵守public/private/protected访问规则静态成员第十一页，共四十五页，2022年，8月28日具有静态数据成员的Point类#include<iostream.h>classPoint {public: Point(intxx=0,intyy=0){X=xx;Y=yy;countP++;}Point(Point&p); intGetX（）{returnX;} intGetY（）{returnY;}

staticvoidGetC（）{cout<<"Objectid="<<countP<<endl;}private: intX,Y;

staticintcountP;};

静态成员第十二页，共四十五页，2022年，8月28日Point::Point(Point&p){ X=p.X; Y=p.Y; countP++;}intPoint::countP=0;

voidmain（） //主函数实现{ PointA(4,5); //声明对象A cout<<"PointA,"<<A.GetX（）<<","<<A.GetY（）; A.GetC（）; //输出对象号，对象名引用

PointB(A); //声明对象B cout<<"PointB,"<<B.GetX（）<<","<<B.GetY（）; B.GetC（）;Point::GetC（）; //输出对象号，类名引用}第十三页，共四十五页，2022年，8月28日静态成员函数类外代码可以使用类名和作用域操作符来调用静态成员函数。静态成员函数只能引用属于该类的静态数据成员或静态成员函数。如果静态成员函数需要访问非静态成员，需要通过对象进行调用。静态成员函数甚至不能使用this指针。第十四页，共四十五页，2022年，8月28日#include<iostream.h>classA{public:staticvoidf(Aa)；private:intx；}；voidA::f(Aa){a.x=0；cout<<x；//对x的引用是错误的

cout<<a.x；//正确}voidmain(){Ab；b.f(b)；}第十五页，共四十五页，2022年，8月28日友元类的重要特点之一是实现了数据隐藏。类的定义中一般将数据成员声明为私有成员，在类的外部不能直接访问私有成员，只能通过类的公有成员函数进行访问。若需要在类的外部直接访问私有数据成员，则需要用到友元来实现这一功能。友元第十六页，共四十五页，2022年，8月28日创建友元创建友元函数的第一步是将其原型放在声明中，并在原型声明前加上关键字friend:friendfloatDistance(Point&a,Point&b);

该原型意味着下面两点：友元第十七页，共四十五页，2022年，8月28日虽然Distance()函数是在类声明中声明的，但它不是成员函数，因此不能使用成员操作符来调用。虽然Distance()函数不是成员函数，但它与成员函数的访问权限相同。第二步是编写函数定义。因为它不是成员函数，所以不要使用Point::限定符。第十八页，共四十五页，2022年，8月28日使用友元函数计算两点距离#include<iostream.h>#include<math.h>classPoint //Point类声明{public: //外部接口

Point(intxx=0,intyy=0){X=xx;Y=yy;} intGetX（）{returnX;} intGetY（）{returnY;}

friendfloatDistance(Point&a,Point&b);

private: //私有数据成员

intX,Y;};友元第十九页，共四十五页，2022年，8月28日doubleDistance(Point&a,Point&b){doubledx=a.X-b.X;doubledy=a.Y-b.Y;returnsqrt(dx*dx+dy*dy);}intmain（）{Pointp1(3.0,5.0),p2(4.0,6.0);doubled=Distance(p1,p2);cout<<"Thedistanceis"<<d<<endl;return0;}第二十页，共四十五页，2022年，8月28日友元类若一个类为另一个类的友元，则此类的所有成员都能访问对方类的私有成员。声明语法：将友元类名在另一个类中使用friend修饰说明。友元第二十一页，共四十五页，2022年，8月28日友元类举例classA{friendclassB；public:voidDisplay（）

{cout<<x<<endl；}private:intx；}classB{public:voidSet(inti)；voidDisplay（）；private:Aa；}；友元第二十二页，共四十五页，2022年，8月28日voidB::Set(inti){a.x=i;}voidB::Display（）{a.Display（）;}第二十三页，共四十五页，2022年，8月28日类作用域类作用域是指在类的声明中用一对花括号括起来的部分。在类中，类的任何成员都可以访问该类的所有成员。对于成员函数，即使函数的实现在花括号的类外，由于函数原型已在类中声明，因此也在类的作用域范围之内。第二十四页，共四十五页，2022年，8月28日一个类的成员函数可以不受限制的访问本类的数据成员，而在该类作用域之外，不能直接访问类的数据成员和成员函数，即使是公有数据成员，也只能通过本类对象才可以访问。第二十五页，共四十五页，2022年，8月28日对象的生存期对象从产生到结束的这段时间就是它的生存期。在对象生存期内，对象将保持它的值，直到被更新为止。第二十六页，共四十五页，2022年，8月28日

对象的生存期一般可以分以下三种情况：局部对象。局部对象是被定义在一个程序块或函数体内的对象，对象被定义时系统自动调用构造函数，该对象被创建，当程序运行结束时该对象被释放。对象的生存期第二十七页，共四十五页，2022年，8月28日

静态对象。静态对象被定义在一个文件中，它的作用域从定义开始到文件结束时止。程序第一次执行静态对象定义语句时，自动调用构造函数创建对象，程序运行结束时调用析构函数释放对象。

对象的生成期第二十八页，共四十五页，2022年，8月28日全局对象。全局对象的作用域在整个程序中，它的作用域范围最大，生存期也最长。对象的生存期第二十九页，共四十五页，2022年，8月28日类作用域及生存期举例#include<iostream.h>classTest{public:Test(inta){i=a;cout<<"Test:"<<i<<endl;}friendvoidfun1(intn);private:inti;};第三十页，共四十五页，2022年，8月28日voidfun1(intn){staticTestt1(n);//静态对象t1cout<<"fun1"<<n<<endl;}voidmain(){Testt2(188);fun1(18);fun1(28);}第三十一页，共四十五页，2022年，8月28日名空间名空间是C++为解决变量、函数名和类名等标识符的命名冲突服务的，它的基本方法是将变量等标识符定义在一个不同名的名空间中。第三十二页，共四十五页，2022年，8月28日名空间说明格式如下：namespace名空间标识符名{

成员的声明；}其中名空间标识符在所定义的域中必须是惟一的，名空间内的成员既包括变量，也包括函数。第三十三页，共四十五页，2022年，8月28日名空间成员的访问格式如下：名空间标识符名::成员名usingnamespacestd；该语句的含义是使用名空间std。使用名空间可以帮助开发人员在开发新的软件组件时不会和已有的软件组件产生标识符命名冲突。第三十四页，共四十五页，2022年，8月28日c++语言提供一个全局的命名空间namespace，可以避免导致全局命名冲突问题。请注意以下两个头文件：//one.h

charfunc(char);

classString{...};//somelib.h

classString{...};如果按照上述方式定义，那么这两个头文件不可能包含在同一个程序中，因为String类会发生冲突。

第三十五页，共四十五页，2022年，8月28日所谓命名空间，是一种将程序库名称封装起来的方法，它就像在各个程序库中立起一道道围墙。比如：

//one.h

namespaceone

{

charfunc(char);

classString{...};

}//somelib.h

namespaceSomeLib

{

classString{...};

}现在就算在同一个程序中使用String类也不会发生冲突了，因为他们分别变成了：one::String()以及Somelib::String()这样，就可以通过声明命名空间来区分不同的类或函数等了第三十六页，共四十五页，2022年，8月28日常类型常类型是指使用关键字const说明的类型，常类型的变量或对象成员的值在程序运行期间是不可改变的。第三十七页，共四十五页，2022年，8月28日常引用常引用所引用的对象不能被更新。如果常引用作为形参，则不会发生对实参的不希望的更改。常引用说明格式如下：const类型说明符&引用名;例如：intn=18;constint&b=n;b是一个常引用量，它所应用的对象不允许更改。如果出现：b=129；则是非法，编译时将产生错误。第三十八页，共四十五页，2022年，8月28日常对象如果在说明对象时用const限定，则被说明的对象为常对象。被说明为常对象的数据成员的值在整个生存周期内不能被修改，常对象只能调用常成员函数。常对象说明格式如下：类名const对象名；或const类名对象名；第三十九页，共四十五页，2022年，8月28日

常成员函数使用const关键字进行说明的成员函数，称为常成员函数。常对象说明格式如下：

类型函数名（参数表）const；

其中，const是加在函数说明后面的类型修饰符，它是函数类型的一个组成部分，因此，在函数实现部分也要带const关键字。第四十页，共四十五页，2022年，8月28日

#include<iostream.h>classR

{public:

R(intr1,intr2){R1=r1;R2=r2;}

voidprint();voidprint()const;//常成员函数private:

intR1,R2;

};

voidR::print()

{

cout<<r1<<","<<r2<<endl;

}

voidR::print()const

{

cout<<r1<<";"<<r2<<endl;

}

voidmain()

{

Ra(5,4);

a.print();

constRb(20,52);

b.print();

}

第四十一页，共四十五页，2022年，8月28日该例子的输出结果为：

5,4

20,52

该程序的类声明了两个成员函数，其类型是不同的(其实就是重载成员函数)。有带const修饰符的成员函数处理const常量，这也体现出函数重载的特点。第四十二页，共四十五页，2022年，8月28日

常数据成员类型修饰符const不仅可以说明成员函数，也可以说明数据成员。

由于const类型对象必