类与对象(本教案改变了教学次序).ppt

1、第五章 类与对象（本教案改变了教学次序）,从本章起将进入面向对象程序设计学习的实质阶段。 封装（Encapsulation）是面向对象程序设计最基本的特性，把数据（属性）和函数（操作）合成一个整体，这在计算机世界中是用类与对象实现的。本章将引入C+的类（class）和对象（object）的概念，建立“函数也可以是数据类型的成员”的思想。本章中用运算符重载来体现类和对象封装的实用性和重要性。 学习程序设计（编制软件）的目的是要解决实际问题，只有具备了从实际问题中抽象出类和对象的能力，才能说初步掌握了面向对象的程序设计的方法。,第五章 类与对象,5.1 类与对象,5.5 运算符的重载,5.4 构造

2、函数和析构函数（下）,5.3 引用,5.2 从面向过程到面向对象,5.9 全局对象与类接口,5.10面向对象的程序设计和Windows编程,5.8 结构和联合,5.7 静态成员,5.6 友元,5.11 对象与类的识别,5.4 构造函数和析构函数（上）,5.1 类与对象,5.1.3对象的创建与使用,5.1.4名字空间域和类域,5.1.1 C+类的定义,5.1.2成员函数的定义,5.1.1 C+类的定义,在C+中，类是一种数据类型。数组和枚举类型是由用户自己定义，自己按规则构造出来的，但其基本组成单位（数据成员）都是同一种数据类型。然而客观事物是复杂的，要描述它必须从多方面进行，也就是用不同的数据

3、类型来描述不同的方面。如商场中的商品可以这样描述： 商品名称（用字符串描述），该商品数量（用整型数描述），该商品单价（用浮点数描述），该商品总价（用浮点数描述）。 这里用了属于三种不同数据类型的四个数据成员（data member）来描述一种商品。,5.1.1 C+类的定义,在C+中可以这样表述： class CGoods public : char Name21 ; /对于中文可用wchar_t name11 int Amount ; float Price ; float Total_value ; ; /最后的分号不可少，这是一条说明语句 上面的表述中，关键字class是数据类型说明符，

4、指出下面说明的是类。标识符CGoods是商品这个类的类型名。花括号中是构成类体的一系列的成员，关键字public是一种访问限定符，表示其后所列为公共成员，就是说可以在外部对这些成员进行访问。,5.1.1 C+类的定义,访问限定符（access specifier）有三种：public（公共的），private（私有的）和protected（保护的），其中后两种说明的成员是不能从外部进行访问的。每种说明符可在类体中使用多次。它们的作用域是从该说明符出现开始到下一个说明符之前或类体结束之前结束。 如果在类体起始点无访问说明符，系统默认定义为私有（private）。 访问说明符private（私有的

5、）和protected（保护的）体现了类具有封装性（Encapsulation）。,5.1.1 C+类的定义,定义一个类的一般格式为： class 类名 private： 成员表1; public: 成员表2; protected: 成员表3; ; /最后的分号不可少;注意：所有说明都有分号 其中“class 类名”称为类头（class head）。花括号中的部分称为类体（class body），类体中定义了类成员表（class member list）。 类定义的更关键部分是对数据成员的操作。这可以用函数来完成。,5.1.1 C+类的定义,这样描述一种商品的完整方式如下： class CGo

6、ods private : char Name21 ; int Amount ; float Price ; float Total_value ; public : void RegisterGoods(char* , int , float) ; /输入数据 void CountTotal(void) ; /计算商品总价值 void GetName(char*) ; /读取商品名 int GetAmount(void) ; /读取商品数量 float GetPrice(void) ; /读取商品单价 float GetTotal_value(void) ; /读取商品总价值 ;,5.1.1

7、 C+类的定义,这样在类中引进了成员函数(member function)或函数成员,也就是函数也成了数据(类)中的一员。类把数据（事物的属性）和函数（事物的行为操作）封装为一个整体。还应注意到:四个数据成员被说明成私有的，而六个函数成员被说明成公有的；这就是说如果从外部对四个数据成员进行操作的话,只能通过六个公有函数来完成,数据受到了良好的保护,不易受副作用的影响。公有函数集定义了类的接口（interface）。 类是一种数据类型，定义时系统并不为类分配存储空间，所以不能对类的数据成员初始化。当然类中的任何数据成员也不能使用关键字extern、auto或register限定其存储类型。 成员

8、函数可以直接使用类定义中的任一成员，可以处理数据成员，也可调用函数成员。,5.1.2成员函数的定义,在前面的小结中，只对成员函数作了一个声明，或者讲只给出了函数的原型，并没有对函数进行定义。函数定义通常在类的说明之后进行，其格式如下： 返回值类型 类名:函数名(参数表) /函数体 其中运算符“:”称为作用域解析运算符(scope resolution operator)，它指出该函数是属于哪一个类的成员函数。当然也可以在类的定义中直接定义函数。但系统处理方法不一样。,5.1.2成员函数的定义,类CGoods的函数可以如下定义： void CGoods:RegisterGoods(char* n

9、ame , int amount , float price) /char*是指向字符的指针类型说明，name现可理解为字符串 strcpy(Name , name) ; /字符串拷贝函数 Amount=amount ; Price=price ; void CGoods:CountTotal(void) Total_value = Price*Amount; void CGoods:GetName(char* name) strcpy(name , Name); int CGoods:GetAmount(void)return(Amount) ; float CGoods:GetPrice(

10、void)return(Price) ; float CGoods:GetTotal_value(void)return(Total_value) ;,对象是类的实例（instance），正如在前几章称变量是数据类型的实例一样。声明一种数据类型只是告诉编译系统该数据类型的结构形式，并没有预定内存，或者讲并没有创建了可用来存放数据的变量。类只是一个样板，以此样板可以在内存中开辟出一个个同样结构的实例对象。 创建类的对象可以有两种常用方法。第一种是直接定义类的实例对象： CGoods Car； 这个定义创建了CGoods类的一个对象Car，同时为它分配了属于它自己的存储块，用来存放数据和对这些数据

11、实施操作的成员函数（代码）。与变量定义一样，一个对象只在定义它的域中有效。 第二种是采用动态创建类的对象的方法，将在第七章中学习。所谓动态指在程序运行时建立对象。而前一种是在编译时（程序运行前）建立。,5.1.3对象的创建与使用,有两种方法可存储对象。,图5.1 各对象完全独立地安排内存的方案,数据区,对象1,数据区,对象,数据区,对象,图5.2 各对象的代码区共用的方案,公共代码区,图5.1是系统为每一个对象分配了全套的内存，包括安放成员数据的数据区和安放成员函数的代码区。但区别同一个类的各个不同的对象的属性是由数据成员决定的，不同对象的数据成员的内容是不一样的；而行为（操作）是用函数来描述

12、的，这些操作的代码对所有的对象都是一样的。图5.2仅为每个对象分配一个数据区，代码区（放成员函数的区域）为各对象类共用。图5.1对应的是在类说明中定义函数，而图5.2对应的是在类说明外部定义函数 。,5.1.3对象的创建与使用,下例给出对象使用的规则 【例5.1】商品类对象应用实例： #include #include #include /省略了类定义,void main( ) CGoodscar ; char string21 ; intnumber ; float pr ;,如果通过使用关键字inline，则系统也会自动采用内联扩展方法实现，这时每个对象都有该函数一份独立的拷贝。如Regi

13、sterGoods()函数可定义为： inline void CGoods:RegisterGoods(char* name , int amount , float price) strcpy(Name,name) ; Amount=amount ; Price=price ; 则每个对象都有RegisterGoods()函数一份独立的拷贝。,成员名 Name21 ; Amount ; Price ; Total_value ;,10,minicar,5,2,10,minicar 5 2,string21 number Pr,minicar,5 2,minicar,coutnumberpr

14、; car.RegisterGoods(string , number , pr) ; car.CountTotal() ; string0=0 ; /字符串string清零 car.GetName(string) ; /string赋值car.Name coutsetw(20)stringsetw(5) car.GetAmount() ; /A coutsetw(10)car.GetPrice()setw(20) car.GetTotal_value()endl ; /B ,5.1.3对象的创建与使用,注意： 因为图5.1的内存分配方法明显不合理，在具体的C+平台中也仅当类的成员函数不包括循

15、环等复杂结构，并这些成员函数的函数体在类定义内部直接定义时，才用内联扩展方式实现。 上面所述对象的存储方式是物理的，这是由计算机来完成的，它并不影响类在逻辑上的封装性。程序设计是一个逻辑的概念，是由人来完成的。从程序员的角度看，逻辑上各对象是完全独立的，不必去管物理上是怎样存储的，所以类的封装在逻辑上是完善的。但若知道物理存储方式，可加深对类与对象的理解，这也是程序员必备的知识。,5.1.3对象的创建与使用,对象使用的规则很简单，只要在对象名后加点号（点操作符，成员访问运算符(member access oprator)之一），再加成员数据或成员函数名就可以了。但是这些成员必须是公有的成员，只

16、有公有成员才能在对象的外面对它进行访问。 如果在上面的例子中的A行和B行写成： coutsetw(20)car.Namesetw(5) car. Amount ; coutsetw(10)car.Pricesetw(20) car.Total_valueendl ; 那就错了，因为这里对象car的4个数据成员全是私有的，在外部是不能访问的，必须用对象car所带的公有函数进行访问。,*5.2从面向过程到面向对象,*供学生阅读： 上世纪六十年代中后期软件危机发生之后，面向过程（procedure-oriented）的结构化程序设计（structured programming,SP）成为主流。结构

17、化程序设计的提出与发展是伴随软件日益庞大和复杂进行的，但是当软件复杂到一定的程度后，结构化程序设计也不能满足需要。当软件规模超过一定的尺度后，采用结构化程序设计，其开发和维护就越来越难控制。其根本的原因就在于面向过程的结构化程序设计的方法与现实世界（包括主观世界和客观世界）往往都不一致，结构化程序设计的思想往往很难贯彻到底。,5.2从面向过程到面向对象,在结构化程序设计中，采用的是“自顶向下，逐步细化（divide and conquer,stepwise refinement）”的思想。它的具体操作方法是模块化，是按功能来分的，所以也称功能块。也就是从一般事物中抽象出来的操作，在C+中称为一

18、个函数，一个函数解决一个问题，即实现一个功能或一个操作。当程序规模和复杂性达到一定程度时不可避免地引入大量的全局变量，优良的模块化没法坚持到底。 在模块化的思想中已经出现了封装的概念，这个封装是把数据封装到模块中，即局部变量。但这是很不彻底的，因为模块是功能的抽象，而数据则是具有其个性的，一但发生那怕是一点变化，抽象的功能模块就不再适用了。如一个管理软件，管理规则变化了，则管理模块以及所有与之有联系的模块都必须更改，必须重新进行功能抽象，必须重新建立模块间联系的规则。可维护性差成了制约结构化程序设计应用的瓶颈。,5.2从面向过程到面向对象,对象的概念是面向对象技术的核心所在。面向对象技术中的对

19、象就是现实世界中某个具体的物理实体在计算机逻辑中的映射和体现。比如你所拥有的一部移动电话，它是现实世界中的一个实体。它由天线、发射部件、接收部件、显示屏、按键、专用集成电路芯片及外壳组成；它有着其实在的功能，可以打电话，可以发短消息，可以存储、输入和编辑各种个人信息，甚至可以上网。这样一个实体可以在计算机世界中映射为一个计算机可以理解、可以操纵、具有前面所叙述的属性和操作的对象。又如你们所拥有的一辆自行车，它由车架、车轮、脚踏和传动机构、变速机构等组成，它具有代步功能，它可以进行变速骑行，特别要强调的是它有一些特征可以把你的这辆自行车与其他自行车区分开来，其中最重要的是钢印号。这些都可以在面向

20、对象的程序中用对象及其属性和操作模拟出来。,5.2从面向过程到面向对象,对象,类,计算机世界,实体,抽象类别,现实世界 客观世界,抽象,抽象,实例化,映射,主观世界,图5.3对象、实体与类,现实世界中的实体可以抽象出类别的概念。对应于计算机世界就有一个类（class）的概念，因为类是一个抽象的概念的对应体，所以计算机不给它分配内存，只给对象分配内存。图5.3表达了计算机世界与现实世界之间的对应关系。,5.4构造函数和析构函数,定义对象时，按现在已学过的知识无法进行初始化，即无法对数据成员进行赋初值的过程。数据成员，从封装的目的出发，应该多为私有的，要对它们进行初始化，看来必须用一个公有函数来进

21、行。同时这个函数应该在且仅在定义对象时自动执行一次，否则就不是初始化了。在C+程序设计语言中这个函数称为构造函数。必须指出：调用构造函数也是建立对象的唯一方法（联合例外，见5.8）。,5.4构造函数和析构函数,5.4.1构造函数的定义与使用,5.4.3析构函数的定义,5.4.4 成员对象与构造函数,5.4.2 拷贝构造函数,对于对象的初始化，采用构造函数（constructor）。当需要对对象进行初始化时，总是编写一个或一组构造函数。构造函数是特殊的公有成员函数，其特征如下： 1.函数名与类名相同。 2.构造函数无函数返回类型说明。注意是没有而不是void，即什么也不写，也不可写void！实际

22、上构造函数有返回值，返回的就是构造函数所创建的对象，见5.5节。 3.在程序运行时，当新的对象被建立，该对象所属的类的构造函数自动被调用，在该对象生存期中也只调用这一次。 4.构造函数可以重载。严格地讲，说明中可以有多个构造函数，它们由不同的参数表区分，系统在自动调用时按一般函数重载的规则选一个执行。,5.4.1构造函数的定义与使用,5.4.1构造函数的定义与使用,5.构造函数可以在类中定义，也可以在类外定义。 6. 如果类说明中没有给出构造函数，则C+编译器自动给出一个缺省的构造函数: 类名(void) 但只要我们定义了一个构造函数，系统就不会自动生成缺省的构造函数。缺省的构造函数，也可以由

23、程序员自己来编，只要构造函数是无参的或者只要各参数均有缺省值的，C+编译器都认为是缺省的构造函数，并且缺省的构造函数只能有一个 。 如果对象的数据成员全为公有的，也可以在对象名后加“=”加“”，在花括号中顺序填入全体数据成员的初始值.,5.4.1构造函数的定义与使用,下面编写5.1节中商品类CGoods的构造函数。可以用三个参数来实现对4个数据成员的初始化： Cgoods (char* name , int amount , float price) strcpy(Name,name) ;Amount=amount ;Price=price ; Total_value=price*amount

24、 ; 在实际应用时，也可用两个参数：货名和单价，这时构造函数为： Cgoods (char* name , float price) strcpy(Name,name) ;Price=price ;Amount=0 ; Total_value=0.0 ; 这两个构造函数同时被说明（重载）。 如果定义对象时的格式为： CGoods Car1(“夏利2000”，30，98000.0); 则调用了CGoods中的第一个构造函数，相当于自动调用： CGoods(“夏利2000”，30，98000.0) ;,5.4.1构造函数的定义与使用,如果定义对象时的格式为： CGoods Car2(“桑塔那200

25、0”，164000.0) ; 则调用的是第二个构造函数，参数为两个。 定义对象初始化时也可以把构造函数显式表示出来如： CGoods Car1= CGoods(“夏利2000”，30，98000.0); 如果还希望初始化时，不带任何参数，可作如下定义： CGoods( )Name0=0 ; Price=0.0 ; Amount=0 ; Total_value=0.0 ; 但是定义对象时不能加括号。例如： CGoods Car3,Car4(); Car3是类CGoods的对象,定义时调用不带参数的构造函数。但是Car4()不是一个对象,而是一个不带参数的函数，它的返回值是类CGoods的对象。,

26、5.4.3析构函数的定义,当一个对象定义时，C+自动调用构造函数建立该对象并进行初始化，那么当一个对象的生命周期结束时，C+也会自动调用一个函数注销该对象并进行善后工作，这个特殊的成员函数即析构函数（destructor）： 1.构函数名与类名相同，但在前面加上字符，如 CGoods（）。 2.析构函数无函数返回类型，与构造函数在这方面是一样的。但析构函数不带任何参数。 3. 一个类有一个也只有一个析构函数，这与构造函数不同。析构函数可以缺省。 4. 对象注销时，系统自动调用析构函数。,5.3引用,在有关函数的学习中，我们知道C+函数中参数的传递方式是传值。在函数域中为参数重新分配内存，而把实

27、参的数值传递到新分配的内存中。它的优点是有效避免函数的副作用，在函数调用中不会无意中修改了实参的值。但如果就是要求改变实参的值，怎么办呢？再者，如果参数是一些简单的数据类型，占据内存不多，重新分配内存问题不大；如果实参是一个复杂的对象，重新分配内存会引起程序执行效率大大下降，怎么办呢?在C+中有一种新的导出型数据类型引用（reference）可以解决上面的难题。引用又称别名（alias）。,5.3引用,引用是一种非常特殊的数据类型，它不是定义一个新的变量，而是给一个已经定义的变量重新起一个别名，也就是C+系统不为引用类型变量分配内存空间。引用主要用于函数之间的数据传递。引用定义的格式为： 类型

28、 newnum是新定义的引用类型变量，它是变量number的别名，内存分配见下图。,number称为引用newnum的关联变量。“ double fsqr1(double a) temp=a*a ; return temp; double 运行结果为： x=30.25 y=30.25 运行结果一样，但在内存中的活动却不同。,5.3引用,*一个声明返回值为引用的函数可以作为左值。可选内容。 【例5.4】统计学生成绩，分数在80分以上的为A类，60分以上，80分以下的为B类，60分以下为C类。 #include int,5.3引用,注意： 1.对数组只能引用数组元素，不能引用数组（数组名本身为地址

29、）。 2.不能定义引用的引用（引用也是地址），所以当函数的参数为引用时，引用不能作实参。,3.const引用：引用在内部存放的是被引用对象的地址，不可寻址的值是不能引用的；当引用作为形参时，实参也不能使用不可寻址的值，更不可能进行类型转换（如：实数转换为整数）。但是const引用不同，它是只读的，为了绝对保证不会发生误改，编译器实现const引用时，生成一个临时对象，引用实际上指向该临时对象，但用户不能访问它。所以const引用可以实现不可寻址的值（包括字面常量）的引用，例如： double dval=1024; const int 因有临时对象，引用和类型转换都实现了。当const引用作为形

30、参时，实参也能使用不可寻址的值，并能进行类型转换（如例5_7后的说明和例5_7_1：调用构造函数将实数转换为复数）。,5.4.2 拷贝构造函数,同一个类的对象在内存中有完全相同的结构，如果作为一个整体进行复制或称拷贝是完全可行的。这个拷贝过程只需要拷贝数据成员，而函数成员是共用的（只有一份拷贝）。在建立对象时可用同一类的另一个对象来初始化该对象，这时所用的构造函数称为拷贝初始化构造函数（Copy Constructor）。 对于CGoods类，可以定义拷贝构造函数为： CGoods (CGoods ,实验六,5.4.4 成员对象与构造函数,5.1.4 名字空间域与类域,5.4.2 拷贝构造函数

31、,这里必须注意拷贝构造函数的参数同类（class）的对象采用的是引用的方式。如果把一个真实的类对象作为参数传递到拷贝构造函数，会引起无穷递归 。所以必须将拷贝构造函数的参数定义为一个类的对象的引用。 通常情况下，这种按成员语义支持已经足够。但在某些情况下，它对类与对象的安全性和处理的正确性还不够，这时就要求类的设计者提供特殊的拷贝构造函数和拷贝赋值操作符的定义。 系统会自动提供，称为缺省的按成员语义支持的拷贝构造函数，每个类成员被依次拷贝，亦称为缺省的按成员初始化。按成员作拷贝是通过依次拷贝每个数据成员实现的，而不是对整个类对象按位拷贝。赋值运算符“=”称缺省的按成员拷贝赋值操作符，同类对象之

32、间可以用“=”直接拷贝 。,5.4.2 拷贝构造函数,当成员函数的参数为同一类（class）的对象或它的引用，在函数体内使用参数对象的私有数据成员时，可用对象名加成员访问操作符点号进行。从逻辑上讲，每个对象有自己的成员函数，访问同类其他对象的私有数据成员应通过该对象的公有函数，不能直接访问。但在物理上只有一个成员函数拷贝，所以直接访问是合理的。其他实例可见5.5节。对本对象的数据成员不加点号，参见6.2节。注意，仅在成员函数中可以这样做。 下面来看一个实例。有一个程序段： CGood Car1(“夏利2000”，30，98000.00);/调用三个参数的构造函数 CGood Car2= Car

33、1;/调用拷贝构造函数 CGood Car3 ( Car1);/调用拷贝构造函数，Car1为实参 这样三个对象的初始化结果完全一样。 在类定义中如果没有显式给出构造函数时，并不是不用构造函数，而是由系统自动调用缺省的构造函数或缺省的拷贝构造函数。如果有程序设计者定义的构造函数（包括拷贝构造函数），则按函数重载的规律，调用合适的构造函数。,5.4.2 拷贝构造函数,拷贝构造函数并不只是在同类的一个对象去初始化该类的另一个对象时使用，它还在另二个方面使用： 1. 当函数的形参是类的对象，调用函数时，进行形参与实参结合时使用。这时要在内存新建立一个局部对象，并把实参拷贝到新的对象中。理所当然也调用拷

34、贝构造函数。 2.当函数的返回值是类对象，函数执行完成返回调用者时使用。理由也是要建立一个临时对象中，再返回调用者。为什么不直接用要返回的局部对象呢？因为局部对象在离开建立它的函数时就消亡了，不可能在返回调用函数后继续生存，所以在处理这种情况时，编译系统会在调用函数的表达式中创建一个无名临时对象，该临时对象的生存周期只在函数调用处的表达式中。所谓return 对象，实际上是调用拷贝构造函数把该对象的值拷入临时对象。如果返回的是变量，处理过程类似，只是不调用构造函数。,实验六 类与对象的实践范例1,范例：设计一个程序，定义一个矩形类，包括数据成员和函数成员。要求有构造函数、析构函数，完成赋值、修

35、改、显示等功能的接口，并编写main函数测试，要求用一个对象初始化另一对象。 分析 要确定一个矩形（四边都是水平或垂直方向，不能倾斜），只要确定其左上角和右下角的x和y坐标即可，因此应包括四个数据成员，left,right,top,bottom，即左右上下四个边界值。由构造函数对数据成员赋值，赋值函数完成未初始化的矩形赋值，修改函数可以修改各数据成员，显示函数则给出该矩形参数。 class Rectangle int left, top, right, bottom; public:Rectangle(int l=0, int t=0, int r=0, int b=0); /缺省构造函数必须

36、在此指定缺省实参 Rectangle()； /析构函数，在此函数体为空 void Assign(int l, int t, int r, int b); void SetLeft(int t) left = t; / 以下皆为内联成员函数 void SetRight( int t ) right = t; void SetTop( int t ) top = t; void SetBottom( int t ) bottom = t; void Show();/将上述内容保存为rect.h,实验六 类与对象的实践范例1,#include #include “rect.h” / 构造函数，带缺省

37、参数，缺省值为全0，在声明中指定Rectangle:Rectangle(int l , int t, int r, int b) left = l; top = t; right = r; bottom = b; void Rectangle:Assign(int l, int t, int r, int b) left = l; top = t; right = r; bottom = b; void Rectangle:Show() coutRectangle(left, top, right, bottom ); / 将上述内容保存为rect.cpp,实验六 类与对象的实践范例1,#in

38、clude #include “rect.h” void main() Rectangle rect; rect.Show(); rect.Assign(100,200,300,400); rect.Show(); Rectangle rect1(0,0,200,200); rect1.Show(); Rectangle rect2（rect1）; rect2.Show(); ,*5.1.4名字空间域和类域,名字空间域内容为阅读，不列入课堂教学! 在C+中支持三种域：局部域、名字空间域和类域。 名字空间域是随标准C+而引入的。它相当于一个更加灵活的文件域（全局域），可以用花括号把文件的一部分括

39、起来，并以关键字namespace开头给它起一个名字，这就是名字空间。例如： namespace ns1 float a,b,c; fun1() 花括号括起来的部分称声明块。声明块中可以包括：类、变量（带有初始化）、函数（带有定义）等。在该域外使用域内的成员时，需加上名字空间名作为前缀，后面加上域操作符“:”，就像在类定义外定义成员函数一样。这里添加了名字空间名称的成员名被称为限定修饰名(qualified name)。如：ns1:a,ns1:fun1()等等。 最外层的名字空间域称为全局名字空间域（global namespace scope），即文件域，对比例4.9在块内访问全局量，只用域

40、操作符“:”。,*5.1.4名字空间域和类域,与局部域分层次一样，名字空间域也可分层嵌套，也同样有分层屏蔽作用。例如： namespace cplusplus_primer namespace Matrixlib/名字空间嵌套 class matrix/名字空间类成员matrix . 访问名字空间域中的成员，使用限定修饰名非常不方便，如访问matrix，每次都写：cplusplus_primer:Matrixlib:matrix 太麻烦。使用using声明可只写一次限定修饰名。using声明以关键字using开头，后面是被限定修饰的（qualified）名字空间成员名： using cplus

41、plus_primer:Matrixlib:matrix;/名字空间类成员matrix的using声明 以后在程序中使用matrix时，就可以直接使用成员名，而不必使用限定修饰名。,*5.1.4名字空间域和类域,名字空间域的引入，主要是为了解决全局名字空间污染（global namespace pollution）问题，即防止程序中的全局实体名与C+各种库中声明的全局实体名冲突。C+库是C+程序员编程最有力的工具，对于标准的和通用的部分，程序员不必也不应该自己编写，程序员的注意力应集中在程序的个性部分。 使用using指示符可以一次性地使名字空间中所有成员都可以直接被使用，比using声明方便

42、。using指示符以关键字using开头，后面是关键字namespace，然后是名字空间名。标准C+库中的所有组件都是在一个被称为std的名字空间中声明和定义的。在采用标准C+的平台上使用标准C+库中的组件，只要写一个using指示符： using namespace std; 就可以直接使用标准C+库中的所有成员。这是很方便的。 名字空间可以不连续，分为多段，但它们仍是同一个名字空间。 名字空间域不能定义在函数声明、函数定义或类定义的内部。,5.1.4名字空间域和类域,类体也定义了一个域称为类域。在类域中说明的标识符仅在该类的类域内有效。必须加上“类名:”作限定修饰。 类的实体对象中的公有成

43、员也可以在对象之外访问，但必须使用成员访问操作符“.”，对象名+“.”+成员名。 定义类本身的目的就是要实现一个封装性，对外是封闭的，对内是开放的，在程序中并不总是需要用成员访问符之类来引用类成员。多数程序代码本身就在类域中，这些程序可以直接访问类成员。,类域作为课堂教学内容，可在此处讲，也可放在5.4.3节之后5.4.4节之前讲，,5.1.4名字空间域和类域,在类域中类成员在类体中被声明的顺序同样很重要，后声明的成员不能被先声明的成员引用。但编译器对名字（标识符）的解析分两步，第一步查找在声明中用到的名字，包括数据成员和函数成员声明中用到的参数类型，第二步才是函数成员体内的名字。例如： cl

44、ass string/字符串类 public: typedef int index_type;/为易读易懂直接用下标型命名 char GetstringElement(index_type elem) /内联函数，取串中第几个元素 return Astringelem;/ Astring未说明 private: char Astring30;/Astring后说明 ; 表面上看是错的；实际上是对的。因为Astring名字的解析是在第一步，而内联函数使用它是在第二步。,5.1.4名字空间域和类域,在类域中不仅有数据和函数成员，也可以有类类型说明，可以称为类成员，或成员类，其作用域为类域，出了类说

45、明之外无效。例如嵌套类： class student public : class studentID/成员类、嵌套类 int value ; public : ; private : studentID id ; /嵌套类说明的私有对象 char name20 ; student s1 , s2 ; student:studentID kk ; 系统并不为嵌套类分配内存空间，即使在student类对象s1和s2中也不为嵌套类studentID分配内存空间，而只为s1.id和s2.id分配内存。在本例中嵌套类studentID在student类外也可以引用，同样要加限定修饰（student：）

46、，因为studentID为公有，如为私有则外部不可引用。嵌套类主要功能是防止全局类说明污染，防止类名重复现象。,5.4.4 成员对象与构造函数,在定义类的对象时不仅要对对象进行初始化，还要先对成员对象进行初始化。对成员对象初始化，必须调用该成员对象的构造函数来实现。 C+中对含对象成员的类对象的构造函数有特殊的格式： 类名:构造函数名(参数总表):对象成员1(参数表1)，对象成员2(参数表2)，对象成员n(参数表n) 冒号后用逗号隔开的为要初始化的对象成员，附在后面的参数表1，参数表n依次为调用相应对象成员所属的构造函数时的实参表。这些表中的参数通常来自冒号前的参数总表。 【例5.5_1】含有

47、成员对象的类的构造函数： #include #include class student public:,class studentID long value; public: studentID(long id=0) value=id; cout赋给学生的学号：valueendl; studentID()cout删除学号：valueendl; ; /学号类定义，注意分号 private: studentID id; char name20; public: student (char* sname=“no name”,long sid=0):id(sid) /sname 现暂看作字符串，ch

48、ar*是指向字符的指针类型 cout“学生名：”snameendl; strcpy(name,sname); ,这样运行结果为： 赋给学生的学号：08002132 学生名：朱明 删去学号：08002132 在student构造函数头部的冒号表示要对对象成员的构造函数进行调用。但在构造函数的声明中，冒号及冒号以后部分必须略去。 *以下供学生阅读： 不用这种格式将无法把学号传递给学号类对象，如例5_5: student(char*sname,long sid=0) /sname 现暂看作字符串，char*是指向字符的指针类型，见第6章； cout学生名：snameendl; strcpy(name

49、,sname); studentID id(sid); /A 目的是将学号转给学号类对象，但未达目的,5.4.4 成员对象与构造函数,5.4.4 成员对象与构造函数,这段程序希望通过构造函数中的A行进行初始化，把学生名“朱明”和学号08002132赋给对象SS。运行结果： 赋给学生的学号：0 /首先调用对象ss的对象成员id的构造函数 学生名：朱明 /对象ss的数据成员name 赋给学生的学号：08002132 /ss构造函数中建立的局部对象id中数据成员value初值 删去学号：08002132 /局部对象id析构 删去学号：0 /对象成员id析构 这表明构造函数中的A行并没有把学号0800

50、2132赋给对象ss中的对象成员id，而是在构造函数中构造了一个名字也为id的studentID局部对象，它只在构造函数中生存，构造函数返回时该局部对象被析构。而对象ss中的对象成员id则因为构造函数中没有指定对它进行初始化的值，所以系统按缺省方式调用了StudentID()建立了对象成员id，所以有第一条输出“赋给学生的学号：0“。 A行也可以写为: studentID: studentID(sid); 结果一样，无法把学号传过去，这时构造函数建立的是一个无名的studentID局部对象。,5.4.4 成员对象与构造函数,对于不含对象成员的类对象的初始化，也可以套用以上的格式，把部分只需要直

51、接赋初值的变量初始化写在冒号的右边： 类名:构造函数名(参数表):变量1(初值1),变量n(初值n) 当然也可以把一部分变量重新放回花括号中的函数体。冒号以后部分实际是函数体的一部分，所以在构造函数的声明中，冒号及冒号以后部分必须略去。,5.4构造函数和析构函数,对于不同作用域的对象类型，构造函数和析构函数的调用如下： 1. 对全局定义的对象，当程序进入入口函数main之前对象就已经定义，这时要调用构造函数。整个程序结束时调用析构函数。 2. 对于局部定义的对象，每当程序控制流到达该对象定义处时，调用构造函数。当程序控制走出该局部域时，则调用析构函数。 3. 对于静态局部定义的对象，在程序控制

52、首次到达该对象定义处时，调用构造函数。当整个程序结束时调用析构函数。,5.4构造函数和析构函数,在正确定义了构造函数和析构函数的前提下，在一个健康的程序中，每个创建的对象必然有一个而且只有一个撤消动作。请读者根据下面程序执行结果，注意每个对象创建和撤消的对应关系： 例5.6演示了对象创建和撤消的对应关系。请参看VC+平台上的演示。 注意：先建立的对象后撤销。 本例可见构造函数和析构函数使用频繁，最好在类说明之外定义构造函数和析构函数，以确保一个函数拷贝，避免代码膨胀。,5.5运算符的重载,运算符的重载实际是一种特殊的函数重载，必须定义一个函数，并告诉C+编译器，当遇到该重载的运算符时调用此函数

53、。这个函数叫做运算符重载函数，通常为类的成员函数。 定义运算符重载函数的一般格式： 返回值类型 类名:operator重载的运算符(参数表) operator是关键字，它与重载的运算符一起构成函数名。因函数名的特殊性，C+编译器可以将这类函数识别出来。 C+中没有复数类型，我们可以自己来定义一个复数类（class），同样可以用+、-、*、/来进行复数的算术运算。,5.5运算符的重载,例5.7定义了复数类，可完成复数基本运算，并应用它进行复数运算。请参看VC+平台上的演示。 class Complex doubleReal,Image ; public : Complex(double r=0.

54、0, double i=0.0):Real(r),Image(i)/定义构造函数 Complex(Complex ,在本例中重载了运算符“+”、“=”、“+=”和“*”、“/”，以及求模（绝对值）的函数abs()，可以进行复数运算。首先来看“+”的重载。 Complex Complex:operator+(Complex c) /显式说明局部对象 Complex Temp(Real+c.Real , Image+c.Image) ; /注意：直接写对象c的私有成员，不用调c的公有函数处理 return Temp ; 在做 c=c2+c3时，C+编译器把表达式c2+c3解释为： c2.opera

55、tor+(c3) ; 这样一个函数调用过程，函数c2.operator创建一个局部的Complex对象Temp，把出现在表达式中的两个Complex类对象c2和c3的实部之和及虚部之和暂存其内，然后把这个局部对象返回，赋给Complex类对象c（注意这里调用了拷贝构造函数生成一个无名临时对象过渡）。参见图5.8。,5.5运算符的重载,Temp.Real=Real+ c2.Real; Temp.Image=Image+ c3.Image; c=return(Temp);,Real Image,c3.Real c3.Image,=,+,局部对象Temp,当前对象c2,对象c3,图5.8 显式说明临

56、时对象的“+”运算符执行过程,可以用隐式的临时对象替换显式的对象Temp，如例中重载的Operator+（double），它执行复数与实数的加法。 Complex Complex:operator+(double d) return Complex(Real+d , Image);/隐式说明局部对象 在return后面跟的是一个表达式，在这里表达式中调用的是类的构造函数，构造函数无返回说明，而不是无返回值，实际上编译器为表达式中的构造函数创立了一个临时对象，临时对象生命期就在该表达式中，返回值就是该临时对象。,5.5运算符的重载,使用引用类型变量作为运算符重载函数的参数，可以提高复数类型运算的

57、效率。复数与复数相加的Operator+成员函数的最终形式： Complex complex:operator+(const complex 这里采用complex对象的引用而不是对象本身，调用时不再重新分配内存建立一个复制的对象，函数效率会更高。而在引用形式参数类型说明前加const关键字，表示被引用的实参是不可改变的，如程序员不当心在函数体中重新赋值了被引用的实参， C+编译器会认为出错。 采用引用为参数时，从理论上讲实参必须为左值，不能为表达式，如【例5.7】中c=c+d是正确的，但c=c+0.5是不允许的，0.5不是左值，但在这种情况下VC+允许。,5.5运算符的重载,在缺省的情况下，

58、C+ 编译器为每个类生成一个缺省的赋值操作，用于同类的两个对象之间的相互赋值，缺省的语义是类成员逐个相互赋值。对复数类 complex 如果没有重载赋值运算符 =，复数的赋值语义是： Complex ,5.5运算符的重载,重载的运算符“+=”标准算法是： Complex /参见6.2节 小结： 1. 运算符重载函数的函数名必须为关键字Operator加一个合法的运算符。在调用该函数时，将右操作数作为函数的实参。,5.5运算符的重载,2.当用类的成员函数实现运算符的重载时，运算符重载函数的参数（当为双目运算符时）为一个或（当为单目运算符时）没有。运算符的左操作数一定是对象，因为重载的运算符是该对象的成员函数，而右操作数是该函数的参数，其类型并无严格限制。C+不允许重载三目运算符。 3.单目运算符“+”和“-”存在前置与后置问题。前置“+”格式为： 返回类型 类名:operator+() 而后置“+”格式为： 返回类型 类名:operator+(int) 后置“+”中的参数int仅用作区