《GIS程序设计第三课》由会员分享，可在线阅读，更多相关《GIS程序设计第三课（62页珍藏版）》请在金锄头文库上搜索。
1、GISGIS程序设计第三课程序设计第三课 类类类类是是是是C+C+语言面向对象程序设计的基础，在语言面向对象程序设计的基础，在语言面向对象程序设计的基础，在语言面向对象程序设计的基础，在C+C+语言面向对象程序设语言面向对象程序设语言面向对象程序设语言面向对象程序设计中占据着核心地位。在面向对象的程序设计中，计中占据着核心地位。在面向对象的程序设计中，计中占据着核心地位。在面向对象的程序设计中，计中占据着核心地位。在面向对象的程序设计中，C+C+程序就是由程序就是由程序就是由程序就是由类的实类的实类的实类的实例例例例对象构成的对象构成的对象构成的对象构成的。 本章将详细介绍有关类及对象的基本知
2、识，并开始采用面向对象程序本章将详细介绍有关类及对象的基本知识，并开始采用面向对象程序本章将详细介绍有关类及对象的基本知识，并开始采用面向对象程序本章将详细介绍有关类及对象的基本知识，并开始采用面向对象程序设计方法进行设计方法进行设计方法进行设计方法进行C+C+编程。编程。编程。编程。类类类类是对对象的抽象和描述，是对对象的抽象和描述，是对对象的抽象和描述，是对对象的抽象和描述，对象是对象是对象是对象是类的实例。类的实例。类的实例。类的实例。类类类类是数据及其相关函数的封装体。能实现数据的封装，使用户在访问对象是数据及其相关函数的封装体。能实现数据的封装，使用户在访问对象是数据及其相关函数的封
3、装体。能实现数据的封装，使用户在访问对象是数据及其相关函数的封装体。能实现数据的封装，使用户在访问对象时不必关心它的内容及它是如何工作的，只需知道它能做什么。时不必关心它的内容及它是如何工作的，只需知道它能做什么。时不必关心它的内容及它是如何工作的，只需知道它能做什么。时不必关心它的内容及它是如何工作的，只需知道它能做什么。类的应用类的应用类的应用类的应用能能能能使有关这个事物的信息都出现在相同的地方，容易定位、复制和处理数据。使有关这个事物的信息都出现在相同的地方，容易定位、复制和处理数据。使有关这个事物的信息都出现在相同的地方，容易定位、复制和处理数据。使有关这个事物的信息都出现在相同的地
4、方，容易定位、复制和处理数据。【 3.1 3.1 类与对象概念的引入类与对象概念的引入类与对象概念的引入类与对象概念的引入】类也是一种用户自定义数据类型。它不仅包含不同数据类型的变量，还包类也是一种用户自定义数据类型。它不仅包含不同数据类型的变量，还包类也是一种用户自定义数据类型。它不仅包含不同数据类型的变量，还包类也是一种用户自定义数据类型。它不仅包含不同数据类型的变量，还包含了对这些变量数据进行操作的函数。含了对这些变量数据进行操作的函数。含了对这些变量数据进行操作的函数。含了对这些变量数据进行操作的函数。类的声明形式如下：类的声明形式如下：类的声明形式如下：类的声明形式如下： class
5、 class 类名类名类名类名 public: public: 若干成员；若干成员；若干成员；若干成员； protected: protected: 若干成员；若干成员；若干成员；若干成员； private: private: 若干成员；若干成员；若干成员；若干成员； ；类类类类是一组变量及其相关函数的组合。类中的是一组变量及其相关函数的组合。类中的是一组变量及其相关函数的组合。类中的是一组变量及其相关函数的组合。类中的变量变量变量变量称为类的成员变量或数据称为类的成员变量或数据称为类的成员变量或数据称为类的成员变量或数据成员；成员；成员；成员；函数函数函数函数称为类的函数成员或方法。称为类的
6、函数成员或方法。称为类的函数成员或方法。称为类的函数成员或方法。成员函数成员函数成员函数成员函数用于处理数据成员，从而描述类的行为，用于处理数据成员，从而描述类的行为，用于处理数据成员，从而描述类的行为，用于处理数据成员，从而描述类的行为， 在类的声明内一般只声在类的声明内一般只声在类的声明内一般只声在类的声明内一般只声明其函数原型，在类外定义函数的实现。明其函数原型，在类外定义函数的实现。明其函数原型，在类外定义函数的实现。明其函数原型，在类外定义函数的实现。指明了这里声指明了这里声指明了这里声指明了这里声明的是一个类明的是一个类明的是一个类明的是一个类类型。类型。类型。类型。是新建类的名称
7、，它是新建类的名称，它是新建类的名称，它是新建类的名称，它是一个标识符。是一个标识符。是一个标识符。是一个标识符。花括号内列出的是类的成员，花括号内列出的是类的成员，花括号内列出的是类的成员，花括号内列出的是类的成员，包括包括包括包括数据成员和成员函数数据成员和成员函数数据成员和成员函数数据成员和成员函数。【 3.2 3.2 类的声明类的声明类的声明类的声明】如果一个成员函数只供类中的其他成员函数调用，也应该如果一个成员函数只供类中的其他成员函数调用，也应该如果一个成员函数只供类中的其他成员函数调用，也应该如果一个成员函数只供类中的其他成员函数调用，也应该声明为私有的声明为私有的声明为私有的声
8、明为私有的。在类的声明中，关键字在类的声明中，关键字在类的声明中，关键字在类的声明中，关键字publicpublic、protectedprotected和和和和privateprivate的出现顺序是任意的，的出现顺序是任意的，的出现顺序是任意的，的出现顺序是任意的，可以不出现或多次出现。类中的每个成员可以不出现或多次出现。类中的每个成员可以不出现或多次出现。类中的每个成员可以不出现或多次出现。类中的每个成员只能有一种特定的访问属性只能有一种特定的访问属性只能有一种特定的访问属性只能有一种特定的访问属性。声明声明声明声明 “ “圆柱体圆柱体圆柱体圆柱体” ”的类的类的类的类class Cyl
9、inderclass Cylinder 公有成员：公有成员：公有成员：公有成员：用关键字用关键字用关键字用关键字 public public声明，其中的成员一般是声明，其中的成员一般是声明，其中的成员一般是声明，其中的成员一般是 成员函数，用于定义类的外部接口，在程成员函数，用于定义类的外部接口，在程成员函数，用于定义类的外部接口，在程成员函数，用于定义类的外部接口，在程 序中的任何部分都可以访问。序中的任何部分都可以访问。序中的任何部分都可以访问。序中的任何部分都可以访问。私有成员：私有成员：私有成员：私有成员：可用关键字可用关键字可用关键字可用关键字 private private声明，其
10、中成员一般是声明，其中成员一般是声明，其中成员一般是声明，其中成员一般是 数据成员，用于描述类的属性，它们只能数据成员，用于描述类的属性，它们只能数据成员，用于描述类的属性，它们只能数据成员，用于描述类的属性，它们只能 被类自身的成员函数访问。被类自身的成员函数访问。被类自身的成员函数访问。被类自身的成员函数访问。类的成员在默类的成员在默类的成员在默类的成员在默 认情况下都是私有的。认情况下都是私有的。认情况下都是私有的。认情况下都是私有的。保护成员：保护成员：保护成员：保护成员：用关键字用关键字用关键字用关键字protectedprotected声明的类成员。声明的类成员。声明的类成员。声明
11、的类成员。类成员按类成员按类成员按类成员按访问权访问权访问权访问权限控制限控制限控制限控制分类分类分类分类例例例例 3-1 3-1 3-1 3-1public: public: / /公有成员，声明类的外部接口公有成员，声明类的外部接口公有成员，声明类的外部接口公有成员，声明类的外部接口 void setcylinder(double r,double h); / void setcylinder(double r,double h); /成员函数，用来设置圆柱体的半径成员函数，用来设置圆柱体的半径成员函数，用来设置圆柱体的半径成员函数，用来设置圆柱体的半径 和高和高和高和高 double g
12、etradius(); double getradius(); / /成员函数，用来获取圆柱体的半径成员函数，用来获取圆柱体的半径成员函数，用来获取圆柱体的半径成员函数，用来获取圆柱体的半径 double getheight(); double getheight(); / /成员函数，用来获取圆柱体的高成员函数，用来获取圆柱体的高成员函数，用来获取圆柱体的高成员函数，用来获取圆柱体的高 double volume(); double volume(); / /成员函数，用来计算圆柱体的体积成员函数，用来计算圆柱体的体积成员函数，用来计算圆柱体的体积成员函数，用来计算圆柱体的体积 double
13、 surface_area(); double surface_area(); / /成员函数，用来计算圆柱体的表面成员函数，用来计算圆柱体的表面成员函数，用来计算圆柱体的表面成员函数，用来计算圆柱体的表面 积积积积private: private: / /私有成员私有成员私有成员私有成员 double radius; double radius; / /数据成员，声明圆柱体的半径数据成员，声明圆柱体的半径数据成员，声明圆柱体的半径数据成员，声明圆柱体的半径 double height double height； / /数据成员，声明圆柱体的高数据成员，声明圆柱体的高数据成员，声明圆柱体的高
14、数据成员，声明圆柱体的高; ;把私有成员的声明放在了最前面，注意这里把私有成员的声明放在了最前面，注意这里把私有成员的声明放在了最前面，注意这里把私有成员的声明放在了最前面，注意这里省略省略省略省略了关键字了关键字了关键字了关键字privateprivateprivateprivate。注注注注说明：把数据成员都声明为私有，并另外建立说明：把数据成员都声明为私有，并另外建立说明：把数据成员都声明为私有，并另外建立说明：把数据成员都声明为私有，并另外建立getradius()getradius()、getheight()getheight()及及及及setcylindersetcylinder(
15、) ()函数来访问这些私有数据成员。使得程序的其他部分对数据成员的访问只函数来访问这些私有数据成员。使得程序的其他部分对数据成员的访问只函数来访问这些私有数据成员。使得程序的其他部分对数据成员的访问只函数来访问这些私有数据成员。使得程序的其他部分对数据成员的访问只能通过公有成员函数来进行，因而数据成员类型改变所产生的影响被控制能通过公有成员函数来进行，因而数据成员类型改变所产生的影响被控制能通过公有成员函数来进行，因而数据成员类型改变所产生的影响被控制能通过公有成员函数来进行，因而数据成员类型改变所产生的影响被控制在类的内部，对程序的其他部分没有影响。在类的内部，对程序的其他部分没有影响。在类
16、的内部，对程序的其他部分没有影响。在类的内部，对程序的其他部分没有影响。 在声明类时把私有成员放在最前面在声明类时把私有成员放在最前面在声明类时把私有成员放在最前面在声明类时把私有成员放在最前面class Cylinderclass Cylinder / /私有成员私有成员私有成员私有成员 double radius; double radius; double height double height；public: /public: /公有成员公有成员公有成员公有成员 void setcylinder(double r,double h); void setcylinder(double
17、r,double h); double getradius(); double getradius(); double getheight(); double getheight(); double volume(); double volume(); double surfacearea(); double surfacearea(); ; 在声明类时，一般来说应该把类的所有数据成员都声明为在声明类时，一般来说应该把类的所有数据成员都声明为在声明类时，一般来说应该把类的所有数据成员都声明为在声明类时，一般来说应该把类的所有数据成员都声明为私有的私有的私有的私有的，同时，同时，同时，同时声明声
18、明声明声明公有成员函数公有成员函数公有成员函数公有成员函数来访问这些数据成员。来访问这些数据成员。来访问这些数据成员。来访问这些数据成员。在类内不允许对声明的数据成员进行初始化。在类内不允许对声明的数据成员进行初始化。在类内不允许对声明的数据成员进行初始化。在类内不允许对声明的数据成员进行初始化。注注注注例例例例 3-2 3-2 3-2 3-2对于成员函数，类的声明内一般对于成员函数，类的声明内一般对于成员函数，类的声明内一般对于成员函数，类的声明内一般只声明只声明只声明只声明其函数原型，其函数原型，其函数原型，其函数原型，具体实现具体实现具体实现具体实现要在要在要在要在类外定义类外定义类外定
19、义类外定义。不能在声明类时给数据成员赋初值不能在声明类时给数据成员赋初值不能在声明类时给数据成员赋初值不能在声明类时给数据成员赋初值class Cylinderclass Cylinder public:public: void setcylinder(double r,double h); void setcylinder(double r,double h); double getradius(); double getradius(); double getheight(); double getheight(); double volume(); double volume(); do
20、uble surfacearea(); double surfacearea();private:private: double radius double radius（5.05.0）; /; /错误，不能在类中给数据成员赋初值错误，不能在类中给数据成员赋初值错误，不能在类中给数据成员赋初值错误，不能在类中给数据成员赋初值 double height=10.0 double height=10.0； / /错误，不能在类中给数据成员赋初值错误，不能在类中给数据成员赋初值错误，不能在类中给数据成员赋初值错误，不能在类中给数据成员赋初值; ; 它的一般格式如下：它的一般格式如下：它的一般格式如下
21、：它的一般格式如下： 返回值类型返回值类型返回值类型返回值类型 类名类名类名类名:成员函数名（参数表）成员函数名（参数表）成员函数名（参数表）成员函数名（参数表） 函数体函数体函数体函数体 “ “: :” ”叫作用域运算符，它标明所叫作用域运算符，它标明所叫作用域运算符，它标明所叫作用域运算符，它标明所要定义的函数属于哪个类。要定义的函数属于哪个类。要定义的函数属于哪个类。要定义的函数属于哪个类。例例例例 3-4 3-4 3-4 3-4“ “圆柱体圆柱体圆柱体圆柱体” ”类成员函数的定义类成员函数的定义类成员函数的定义类成员函数的定义void Cylinder:setcylinder(doub
22、le r,double h)void Cylinder:setcylinder(double r,double h) radius=r; radius=r; height=h; height=h; double Cylinder:getradius()double Cylinder:getradius() return radius; return radius; double Cylinder:getheight()double Cylinder:getheight() return height; return height; double Cylinder: volume()double
23、 Cylinder: volume() double vol; double vol; vol=3.1415926*radius*radius*height; vol=3.1415926*radius*radius*height; return vol; return vol; 例例例例 3-5 3-5 3-5 3-5double Cylinder:surfacearea()double Cylinder:surfacearea() double area; double area; area=2*3.1415926*radius*height+2*3.1415926*radius*radiu
24、s; area=2*3.1415926*radius*height+2*3.1415926*radius*radius; return area; return area; 在定义类的成员函数时，也可以对参数设置默认值。在定义类的成员函数时，也可以对参数设置默认值。在定义类的成员函数时，也可以对参数设置默认值。在定义类的成员函数时，也可以对参数设置默认值。在定义成员函数时可以为参数设默认值在定义成员函数时可以为参数设默认值在定义成员函数时可以为参数设默认值在定义成员函数时可以为参数设默认值void Cylinder:setcylinder(double r=0,double h=0)void
25、Cylinder:setcylinder(double r=0,double h=0) radius=r;radius=r;height=h;height=h; 定义类的成员函数时，对一些只有一、二条语句的函数可以把函数定义成定义类的成员函数时，对一些只有一、二条语句的函数可以把函数定义成定义类的成员函数时，对一些只有一、二条语句的函数可以把函数定义成定义类的成员函数时，对一些只有一、二条语句的函数可以把函数定义成内内内内联函数联函数联函数联函数。内联成员函数的定义内联成员函数的定义内联成员函数的定义内联成员函数的定义在类的声明中定义在类的声明中定义在类的声明中定义在类的声明中定义在类外定义在
26、类外定义在类外定义在类外定义例例例例 3-6 3-6 3-6 3-6在类外定义内联成员函数在类外定义内联成员函数在类外定义内联成员函数在类外定义内联成员函数inline double Cylinder:getradius()inline double Cylinder:getradius() return radius; return radius; inline double Cylinder:getheight()inline double Cylinder:getheight() return height; return height; 函数体的定义函数体的定义函数体的定义函数体的定义
27、放在类的声明内放在类的声明内放在类的声明内放在类的声明内，定义的函数就，定义的函数就，定义的函数就，定义的函数就自动成为自动成为自动成为自动成为内联成员函数。内联成员函数。内联成员函数。内联成员函数。例例例例 3-8 3-8 3-8 3-8在类的声明内直接定义成员函数在类的声明内直接定义成员函数在类的声明内直接定义成员函数在类的声明内直接定义成员函数class Cylinderclass Cylinder public:public: void setcylinder(double r,double h); void setcylinder(double r,double h); double
28、 getradius() double getradius() return radius; return radius; 说明：在类外定义一个类的内说明：在类外定义一个类的内说明：在类外定义一个类的内说明：在类外定义一个类的内联成员函数，应该在联成员函数，应该在联成员函数，应该在联成员函数，应该在函数类型函数类型函数类型函数类型之前之前之前之前用关键字用关键字用关键字用关键字inlineinline进行说明。进行说明。进行说明。进行说明。例例例例 3-7 3-7 3-7 3-7 在实际的在实际的在实际的在实际的C+C+C+C+程序设计中，把类的声明和类外实现的成员函数程序设计中，把类的声明和
29、类外实现的成员函数程序设计中，把类的声明和类外实现的成员函数程序设计中，把类的声明和类外实现的成员函数放在不同的文件中。其中放在不同的文件中。其中放在不同的文件中。其中放在不同的文件中。其中类的声明类的声明类的声明类的声明放在一个称为放在一个称为放在一个称为放在一个称为头文件头文件头文件头文件的文件中，的文件中，的文件中，的文件中，成员函数的定义成员函数的定义成员函数的定义成员函数的定义放在另一个称为放在另一个称为放在另一个称为放在另一个称为源文件源文件源文件源文件的文件中。的文件中。的文件中。的文件中。注注注注头文件与源文件的头文件与源文件的头文件与源文件的头文件与源文件的名字一般相同名字一
30、般相同名字一般相同名字一般相同。头文件的扩展名为头文件的扩展名为头文件的扩展名为头文件的扩展名为.H.H（或（或（或（或.HPP.HPP）；源文件的扩展名为；源文件的扩展名为；源文件的扩展名为；源文件的扩展名为.CPP.CPP。说明：在类的声明内定义函数时，必说明：在类的声明内定义函数时，必说明：在类的声明内定义函数时，必说明：在类的声明内定义函数时，必须注意的是在表示函数结束的花括号须注意的是在表示函数结束的花括号须注意的是在表示函数结束的花括号须注意的是在表示函数结束的花括号后，后，后，后，不能加分号不能加分号不能加分号不能加分号。例例例例 3-8 3-8 3-8 3-8double ge
31、theight()double getheight() return height; return height; double volume(); double volume(); double surface_area(); double surface_area();private:private: double radius; double radius; double height double height； 在类的声明内直接定义成员函数在类的声明内直接定义成员函数在类的声明内直接定义成员函数在类的声明内直接定义成员函数这其实和一般变量的声明方式是一样的。这其实和一般变量的声明方式
32、是一样的。这其实和一般变量的声明方式是一样的。这其实和一般变量的声明方式是一样的。类类类类是数据和其相关操作函数的封装体，是对对象的抽象及其共性的描述，是数据和其相关操作函数的封装体，是对对象的抽象及其共性的描述，是数据和其相关操作函数的封装体，是对对象的抽象及其共性的描述，是数据和其相关操作函数的封装体，是对对象的抽象及其共性的描述，对象是对象是对象是对象是类的实例。类被当作一个类的实例。类被当作一个类的实例。类被当作一个类的实例。类被当作一个自定义的数据类型自定义的数据类型自定义的数据类型自定义的数据类型，一个类的对象可以看，一个类的对象可以看，一个类的对象可以看，一个类的对象可以看成是成
33、是成是成是该类型的一个变量该类型的一个变量该类型的一个变量该类型的一个变量。对象也必须经过声明后才能使用。在声明了相应的类后，声明这个类的对象。对象也必须经过声明后才能使用。在声明了相应的类后，声明这个类的对象。对象也必须经过声明后才能使用。在声明了相应的类后，声明这个类的对象。对象也必须经过声明后才能使用。在声明了相应的类后，声明这个类的对象。 方式如下：方式如下：方式如下：方式如下： 类名类名类名类名 对象名；对象名；对象名；对象名； 例如：例如：例如：例如： Cylinder cylinder1,cylinder2;Cylinder cylinder1,cylinder2;Cylinde
34、r cylinder1,cylinder2;Cylinder cylinder1,cylinder2;可以声明对象数组。可以声明对象数组。可以声明对象数组。可以声明对象数组。例如：例如：例如：例如： Cylinder cylinder1Cylinder cylinder1Cylinder cylinder1Cylinder cylinder110101010; ; ; ;声明了两个名字分别为声明了两个名字分别为声明了两个名字分别为声明了两个名字分别为cylinder1cylinder1、cylinder2cylinder2的类的类的类的类CylinderCylinder的对象。的对象。的对象。
35、的对象。声明了一个数组声明了一个数组声明了一个数组声明了一个数组cylinder1cylinder1，其中共有，其中共有，其中共有，其中共有1010个元素，每个元素都是一个对象。个元素，每个元素都是一个对象。个元素，每个元素都是一个对象。个元素，每个元素都是一个对象。【 3.3 3.3 对象的声明对象的声明对象的声明对象的声明】可以使用成员选择运算符可以使用成员选择运算符可以使用成员选择运算符可以使用成员选择运算符“. . . .”来访问对象中的公有成员。来访问对象中的公有成员。来访问对象中的公有成员。来访问对象中的公有成员。其一般形式如下：其一般形式如下：其一般形式如下：其一般形式如下：对象
36、名对象名对象名对象名. . . .数据成员名数据成员名数据成员名数据成员名 / / / /访问数据成员访问数据成员访问数据成员访问数据成员 对象名对象名对象名对象名. . . .成员函数名（参数表）成员函数名（参数表）成员函数名（参数表）成员函数名（参数表） / / / /访问成员函数访问成员函数访问成员函数访问成员函数只有在声明这个类的对象时，才实际分配相应的内存。编译器在声明一个只有在声明这个类的对象时，才实际分配相应的内存。编译器在声明一个只有在声明这个类的对象时，才实际分配相应的内存。编译器在声明一个只有在声明这个类的对象时，才实际分配相应的内存。编译器在声明一个对象时只是为对象的数据
37、成员分配内存，并不需要为成员函数分配存储空对象时只是为对象的数据成员分配内存，并不需要为成员函数分配存储空对象时只是为对象的数据成员分配内存，并不需要为成员函数分配存储空对象时只是为对象的数据成员分配内存，并不需要为成员函数分配存储空间。由于对同一类的对象，成员函数的代码是相同的，故系统一次性地为间。由于对同一类的对象，成员函数的代码是相同的，故系统一次性地为间。由于对同一类的对象，成员函数的代码是相同的，故系统一次性地为间。由于对同一类的对象，成员函数的代码是相同的，故系统一次性地为之分配内存。之分配内存。之分配内存。之分配内存。例如：例如：例如：例如： cylinder1.volume()
38、cylinder1.volume()cylinder1.volume()cylinder1.volume()例如：例如：例如：例如： Cylinder cylinder1; Cylinder cylinder1; Cylinder cylinder1; Cylinder cylinder1; cylinder1.radius=6.0; cylinder1.radius=6.0; cylinder1.radius=6.0; cylinder1.radius=6.0;只能只能只能只能给变量赋值。首先声明一个属于该类的对象，然后给这个变量赋值。给变量赋值。首先声明一个属于该类的对象，然后给这个变量赋
39、值。给变量赋值。首先声明一个属于该类的对象，然后给这个变量赋值。给变量赋值。首先声明一个属于该类的对象，然后给这个变量赋值。例如：例如：例如：例如： A aobject; A aobject; A aobject; A aobject; aobject.X=5; aobject.X=5; aobject.X=5; aobject.X=5;在类外使用下面的方法是错误的。在类外使用下面的方法是错误的。在类外使用下面的方法是错误的。在类外使用下面的方法是错误的。 正确的。正确的。正确的。正确的。私有成员私有成员私有成员私有成员只能只能只能只能被类内的成员函数访问。被类内的成员函数访问。被类内的成员函
40、数访问。被类内的成员函数访问。一个一个一个一个C+C+面向对象程序设计的例子面向对象程序设计的例子面向对象程序设计的例子面向对象程序设计的例子/ /求圆柱体的体积及表面积求圆柱体的体积及表面积求圆柱体的体积及表面积求圆柱体的体积及表面积/EXAMPLE3_9.H/EXAMPLE3_9.H#include#includeclass Cylinder class Cylinder / /声明圆柱体类声明圆柱体类声明圆柱体类声明圆柱体类 public:public: void setcylinder(double r=5.0,double h=10.0); void setcylinder(doub
41、le r=5.0,double h=10.0); double getradius() double getradius() return radius; return radius; double getheight() double getheight() return height; return height; double volume(); double volume(); / /声明求体积函数的原型声明求体积函数的原型声明求体积函数的原型声明求体积函数的原型 double surface_area(); double surface_area(); / /声明求表面积函数的原型声
42、明求表面积函数的原型声明求表面积函数的原型声明求表面积函数的原型private:private: double radius; double radius; / /底圆半径底圆半径底圆半径底圆半径 double height double height； / /圆柱体高圆柱体高圆柱体高圆柱体高; ; 第第第第1 1部分部分部分部分例例例例 3-9 3-9 3-9 3-9/EXAMPLE3_9.CPP/EXAMPLE3_9.CPP#includeEXAMPLE3_9.H#includeEXAMPLE3_9.Hconst double PI=3.1415926;const double PI=3.
43、1415926;void Cylinder:setcylinder(double r,double h) void Cylinder:setcylinder(double r,double h) / /定义函数设置半径和高定义函数设置半径和高定义函数设置半径和高定义函数设置半径和高 radius=r; radius=r; height=h; height=h; double Cylinder: volume() double Cylinder: volume() / /定义函数求体积定义函数求体积定义函数求体积定义函数求体积 double vol; double vol; vol=PI*rad
44、ius*radius*height; vol=PI*radius*radius*height; return vol; return vol; double Cylinder:surface_area() double Cylinder:surface_area() / /定义函数求表面积定义函数求表面积定义函数求表面积定义函数求表面积 double area; double area; area=2*PI*radius*height+2*PI*radius*radius; area=2*PI*radius*height+2*PI*radius*radius; return area; ret
45、urn area; 第第第第2 2部分部分部分部分（续）（续）（续）（续）void main()void main() Cylinder cylinder1,cylinder2; Cylinder cylinder1,cylinder2; / /声明圆柱体对象声明圆柱体对象声明圆柱体对象声明圆柱体对象cylinder1.setcylinder(); cylinder1.setcylinder(); / /给对象给对象给对象给对象cylinder1cylinder1半径和高赋值半径和高赋值半径和高赋值半径和高赋值cylinder2.setcylinder(10.2,15.6); cylinder
46、2.setcylinder(10.2,15.6); / /给对象给对象给对象给对象cylinder2cylinder2半径和高赋值半径和高赋值半径和高赋值半径和高赋值cout The radius of the first cylinder is:cout The radius of the first cylinder is:t cylinder1.getradius()endl;t cylinder1.getradius()endl; / /输出对象输出对象输出对象输出对象cylinder1cylinder1的半径的半径的半径的半径cout The height of the first
47、cylinder is:cout The height of the first cylinder is:t cylinder1.getheight()endl;t cylinder1.getheight()endl; / /输出对象输出对象输出对象输出对象cylinder1cylinder1的高的高的高的高cout The volume of the first cylinder is:cout The volume of the first cylinder is:t cylinder1.volume()endl;t cylinder1.volume()endl; / /计算对象计算对象计
48、算对象计算对象cylinder1cylinder1的体积，并输出的体积，并输出的体积，并输出的体积，并输出cout The surface area of the first cylinder is:cout The surface area of the first cylinder is:t t cylinder1.surface_area()endl; cylinder1.surface_area()endl; / /计算对象计算对象计算对象计算对象cylinder1cylinder1的表面积，并输出的表面积，并输出的表面积，并输出的表面积，并输出cout The radius of t
49、he second cylinder is:cout The radius of the second cylinder is:t cylinder2.getradius()endl;t cylinder2.getradius()endl; / /输出对象输出对象输出对象输出对象cylinder2cylinder2的半径的半径的半径的半径cout The height of the second cylinder is:cout The height of the second cylinder is:t cylinder2.getheight()endl; t cylinder2.gethe
50、ight()endl; / /输出对象输出对象输出对象输出对象cylinder2cylinder2的高的高的高的高cout The volume of the second cylinder is:cout The volume of the second cylinder is:t cylinder2.volume()endl;t cylinder2.volume()endl; / /计算对象计算对象计算对象计算对象cylinder2cylinder2的体积，并输出的体积，并输出的体积，并输出的体积，并输出第第第第3 3部分部分部分部分（续）（续）（续）（续）cout The surface
51、 area of the second cylinder is:cout The surface area of the second cylinder is:t t cylinder2.surface_area()endl;cylinder2.surface_area()endl;/ /计算对象计算对象计算对象计算对象cylinder2cylinder2的表面积，并输出的表面积，并输出的表面积，并输出的表面积，并输出 The radius of the first cylinder is: 5The radius of the first cylinder is: 5The height o
52、f the first cylinder is: 10The height of the first cylinder is: 10The volume of the first cylinder is: 785.398The volume of the first cylinder is: 785.398The surface area of the first cylinder is: 471.239The surface area of the first cylinder is: 471.239The radius of the second cylinder is: 10.2The
53、radius of the second cylinder is: 10.2The height of the second cylinder is: 15.5The height of the second cylinder is: 15.5The volume of the second cylinder is: 5098.88The volume of the second cylinder is: 5098.88The surface area of the second cylinder is: 1653.48The surface area of the second cylind
54、er is: 1653.48说明：程序由说明：程序由说明：程序由说明：程序由3 3个相对独立的部分组成。个相对独立的部分组成。个相对独立的部分组成。个相对独立的部分组成。 第第第第1 1部分是类部分是类部分是类部分是类CylinderCylinder的声明，存储在的声明，存储在的声明，存储在的声明，存储在EXAMPLE3_9.HEXAMPLE3_9.H文件中；文件中；文件中；文件中； 第第第第2 2部分是类部分是类部分是类部分是类CylinderCylinder的成员函数的实现，存储在的成员函数的实现，存储在的成员函数的实现，存储在的成员函数的实现，存储在 EXAMPLE3_9.CPP EXA
55、MPLE3_9.CPP文件中；文件中；文件中；文件中； 第第第第3 3部分是主函数部分是主函数部分是主函数部分是主函数main()main()。（续）（续）（续）（续）作为数据成员的对象所属的类，应该在声明这个对象之前进行声明。作为数据成员的对象所属的类，应该在声明这个对象之前进行声明。作为数据成员的对象所属的类，应该在声明这个对象之前进行声明。作为数据成员的对象所属的类，应该在声明这个对象之前进行声明。注注注注可以为类作可以为类作可以为类作可以为类作引用性声明引用性声明引用性声明引用性声明。这种声明。这种声明。这种声明。这种声明只声明类名只声明类名只声明类名只声明类名，即只为程序引入了一个类
56、，即只为程序引入了一个类，即只为程序引入了一个类，即只为程序引入了一个类标识符，而标识符的标识符，而标识符的标识符，而标识符的标识符，而标识符的实际意义实际意义实际意义实际意义在其他部分定义。这种引用性声明引入的标在其他部分定义。这种引用性声明引入的标在其他部分定义。这种引用性声明引入的标在其他部分定义。这种引用性声明引入的标识符，在其识符，在其识符，在其识符，在其实际意义未定义前实际意义未定义前实际意义未定义前实际意义未定义前只能被用于声明函数原型等场合。只能被用于声明函数原型等场合。只能被用于声明函数原型等场合。只能被用于声明函数原型等场合。类的数据成员可以是类类型，也就是说类的声明中数据
57、成员可以是另一个类的数据成员可以是类类型，也就是说类的声明中数据成员可以是另一个类的数据成员可以是类类型，也就是说类的声明中数据成员可以是另一个类的数据成员可以是类类型，也就是说类的声明中数据成员可以是另一个类的对象。类的对象。类的对象。类的对象。这个对象不能是本类的对象。这个对象不能是本类的对象。这个对象不能是本类的对象。这个对象不能是本类的对象。正确的正确的正确的正确的如：如：如：如：class Aclass Aclass Aclass A . class Bclass Bclass Bclass B .A a;A a;A a;A a;.; 对于程序中声明的每一个对象，编译器都要为之确定存
58、储的布局。但引对于程序中声明的每一个对象，编译器都要为之确定存储的布局。但引对于程序中声明的每一个对象，编译器都要为之确定存储的布局。但引对于程序中声明的每一个对象，编译器都要为之确定存储的布局。但引 用性声明中并未说明对象的数据结构，以及对数据的相关操作。用性声明中并未说明对象的数据结构，以及对数据的相关操作。用性声明中并未说明对象的数据结构，以及对数据的相关操作。用性声明中并未说明对象的数据结构，以及对数据的相关操作。 编译器不仅不能为对象分配内存空间，也无法对对象能参与的操作进行编译器不仅不能为对象分配内存空间，也无法对对象能参与的操作进行编译器不仅不能为对象分配内存空间，也无法对对象能
59、参与的操作进行编译器不仅不能为对象分配内存空间，也无法对对象能参与的操作进行 类型检查。类型检查。类型检查。类型检查。只经过引用性声明的类标识符，不能用于建立对象。只经过引用性声明的类标识符，不能用于建立对象。只经过引用性声明的类标识符，不能用于建立对象。只经过引用性声明的类标识符，不能用于建立对象。如：如：如：如： class B class B； class A class A public: public: void fun(B b); void fun(B b); . . ; ; class B class B . . ; ;class Bclass B； / /引用性声明引用性声明引
60、用性声明引用性声明class Aclass A public:public: void fun(B b); void fun(B b); / /正确正确正确正确private:private: B b; B b; / /错误，类错误，类错误，类错误，类B B尚未定义尚未定义尚未定义尚未定义; ;void A:fun(B b)void A:fun(B b) coutb.getx; coutb.getx; / /错误错误错误错误 class B class B / /声明类声明类声明类声明类B B，也即定义类，也即定义类，也即定义类，也即定义类B B public:public:void setx
61、(int a)x=a;void setx(int a)x=a;int getx() return x;int getx() return x;private:private: int x; int x; ;例如：例如：例如：例如：下面的使用方法就是错误的。下面的使用方法就是错误的。下面的使用方法就是错误的。下面的使用方法就是错误的。在声明对象时，也可以对其数据成员在声明对象时，也可以对其数据成员在声明对象时，也可以对其数据成员在声明对象时，也可以对其数据成员初始化初始化初始化初始化。对象数据成员的初始化需要。对象数据成员的初始化需要。对象数据成员的初始化需要。对象数据成员的初始化需要通过类的特
62、殊成员函数来进行，这个成员函数就是通过类的特殊成员函数来进行，这个成员函数就是通过类的特殊成员函数来进行，这个成员函数就是通过类的特殊成员函数来进行，这个成员函数就是构造函数构造函数构造函数构造函数。构造函数构造函数构造函数构造函数是类的特殊成员函数，用于在声明类的对象时对其进行初始化。是类的特殊成员函数，用于在声明类的对象时对其进行初始化。是类的特殊成员函数，用于在声明类的对象时对其进行初始化。是类的特殊成员函数，用于在声明类的对象时对其进行初始化。构造函数的函数名构造函数的函数名构造函数的函数名构造函数的函数名应与类名相同，应与类名相同，应与类名相同，应与类名相同，构造函数中的参数构造函数
63、中的参数构造函数中的参数构造函数中的参数根据需要可有可无。根据需要可有可无。根据需要可有可无。根据需要可有可无。不能为其指定返回值类型不能为其指定返回值类型不能为其指定返回值类型不能为其指定返回值类型，甚至连，甚至连，甚至连，甚至连voidvoid也不可以也不可以也不可以也不可以。【 3.4.1 3.4.1 构造函数构造函数构造函数构造函数】构造函数应被构造函数应被构造函数应被构造函数应被声明为公有函数声明为公有函数声明为公有函数声明为公有函数，它只能在创建类的对象时由系统自动调，它只能在创建类的对象时由系统自动调，它只能在创建类的对象时由系统自动调，它只能在创建类的对象时由系统自动调用，对对
64、象进行初始化，程序的用，对对象进行初始化，程序的用，对对象进行初始化，程序的用，对对象进行初始化，程序的其他部分不能调用其他部分不能调用其他部分不能调用其他部分不能调用。class Cylinderclass Cylinder public:public: Cylinder(); Cylinder(); void setcylinder(double r,double h); void setcylinder(double r,double h);例例例例 3-10 3-10 3-10 3-10圆柱体类构造函数圆柱体类构造函数圆柱体类构造函数圆柱体类构造函数不带参数不带参数不带参数不带参数的情
65、形的情形的情形的情形【 3.4 3.4 构造函数与析构函数构造函数与析构函数构造函数与析构函数构造函数与析构函数】 double getradius(); double getradius(); double getheight(); double getheight(); double volume(); double volume(); double surface_area(); double surface_area();private:private: double radius; double radius; double height double height；; ; Cyli
66、nder:Cylinder()Cylinder:Cylinder() radius=5.0; radius=5.0; height=10.0; height=10.0; class Cylinderclass Cylinder public:public: Cylinder(double r,double h); Cylinder(double r,double h); void setcylinder(double r,double h); void setcylinder(double r,double h);圆柱体类构造函数圆柱体类构造函数圆柱体类构造函数圆柱体类构造函数带有参数带有参数
67、带有参数带有参数的情形的情形的情形的情形例例例例 3-11 3-11 3-11 3-11 double getradius(); double getradius(); double getheight(); double getheight(); double volume(); double volume(); double surface_area(); double surface_area();private:private: double radius; double radius; double height double height；; ; Cylinder:Cylinder
68、(double r,double h)Cylinder:Cylinder(double r,double h) radius=r; radius=r; height=h; height=h; 在声明对象时，就必须在声明对象时，就必须在声明对象时，就必须在声明对象时，就必须利用实参对对象进行初始化利用实参对对象进行初始化利用实参对对象进行初始化利用实参对对象进行初始化。例如：例如：例如：例如： Cylinder cylinder1(2.0,3.0); Cylinder cylinder1(2.0,3.0); Cylinder cylinder1; / Cylinder cylinder1; /错
69、误，没有提供用于初始化的实参错误，没有提供用于初始化的实参错误，没有提供用于初始化的实参错误，没有提供用于初始化的实参在声明对象时，如果相应的构造函数在声明对象时，如果相应的构造函数在声明对象时，如果相应的构造函数在声明对象时，如果相应的构造函数没有形参没有形参没有形参没有形参，括号应该，括号应该，括号应该，括号应该省略省略省略省略。（续）（续）（续）（续）若是声明对象数组，应该采用下述形式：若是声明对象数组，应该采用下述形式：若是声明对象数组，应该采用下述形式：若是声明对象数组，应该采用下述形式：Cylinder cylinder1Cylinder cylinder13 3= Cylinde
70、r (1.0,2.0)= Cylinder (1.0,2.0)，Cylinder(3.0,4.0),Cylinder(5.0,6.0);Cylinder(3.0,4.0),Cylinder(5.0,6.0);构造函数也可以定义为构造函数也可以定义为构造函数也可以定义为构造函数也可以定义为内联函数内联函数内联函数内联函数，可以，可以，可以，可以带默认形参值带默认形参值带默认形参值带默认形参值，也可以，也可以，也可以，也可以重载重载重载重载。/ /这个程序在【例这个程序在【例这个程序在【例这个程序在【例3 3 - - - - 9 9】的基础上增加了构造函数】的基础上增加了构造函数】的基础上增加了构
71、造函数】的基础上增加了构造函数/EXAMPLE3_12.H/EXAMPLE3_12.H#include#includeclass Cylinderclass Cylinderpublic:public: Cylinder() / Cylinder() /构造函数构造函数构造函数构造函数 Cylinder(double r,double h); / Cylinder(double r,double h); /构造函数构造函数构造函数构造函数 void setcylinder(double r,double h);void setcylinder(double r,double h); doubl
72、e getradius() double getradius() return radius; return radius; 构造函数的构造函数的构造函数的构造函数的重载重载重载重载 第第第第1 1部分部分部分部分说明：对类说明：对类说明：对类说明：对类CylinderCylinder的构造的构造的构造的构造函数进行了重载。函数进行了重载。函数进行了重载。函数进行了重载。没有形参，函没有形参，函没有形参，函没有形参，函数体也为空。数体也为空。数体也为空。数体也为空。有两个形参。有两个形参。有两个形参。有两个形参。例例例例 3-12 3-12 3-12 3-12double getheight(
73、)double getheight() return height; return height; double volume(); double volume(); double surface_area(); double surface_area();private:private: double radius; double radius; double height double height；; ; /EXAMPLE3_12.CPP/EXAMPLE3_12.CPP#includeEXAMPLE3_12.H#includeEXAMPLE3_12.Hconst double PI=3.
74、1415926;const double PI=3.1415926;Cylinder:Cylinder(double r,double h)Cylinder:Cylinder(double r,double h) radius=r; radius=r; height=h; height=h; 第第第第1 1部分部分部分部分第第第第2 2部分部分部分部分（续）（续）（续）（续）void Cylinder:setcylinder(double r,double h)void Cylinder:setcylinder(double r,double h) radius=r; radius=r; he
75、ight=h; height=h; double Cylinder: volume()double Cylinder: volume() double vol; double vol; vol=PI*radius*radius*height; return vol; vol=PI*radius*radius*height; return vol; double Cylinder:surface_area()double Cylinder:surface_area() double area; double area; area=2*PI*radius*height+2*PI*radius*ra
76、dius; area=2*PI*radius*height+2*PI*radius*radius; return area; return area; void main()void main() Cylinder cylinder1(5.0,10.0),cylinder2; /Cylinder cylinder1(5.0,10.0),cylinder2; /声明对象声明对象声明对象声明对象cylinder2.setcylinder(10.2,15.6);cylinder2.setcylinder(10.2,15.6);第第第第2 2部分部分部分部分带有两个实参，系统将自动调用第带有两个实参，
77、系统将自动调用第带有两个实参，系统将自动调用第带有两个实参，系统将自动调用第2 2个个个个构造函数给对象构造函数给对象构造函数给对象构造函数给对象cylinder1cylinder1初始化。初始化。初始化。初始化。在声明时调用第一个构造函数。在声明时调用第一个构造函数。在声明时调用第一个构造函数。在声明时调用第一个构造函数。（续）（续）（续）（续）注注注注 自动生成的默认构造函数自动生成的默认构造函数自动生成的默认构造函数自动生成的默认构造函数不带任何参数，在函数体内也不带任何参数，在函数体内也不带任何参数，在函数体内也不带任何参数，在函数体内也没有任何语没有任何语没有任何语没有任何语句，不执
78、行任何操作。句，不执行任何操作。句，不执行任何操作。句，不执行任何操作。cout The radius of the first cylinder is:cout The radius of the first cylinder is:tcylinder1.getradius()endl;tcylinder1.getradius()endl;cout The height of the first cylinder is:cout The height of the first cylinder is:t cylinder1.getheight()endl;t cylinder1.gethei
79、ght()endl;cout The volume of the first cylinder is:cout The volume of the first cylinder is:t cylinder1.volume()endl;t cylinder1.volume()endl;cout The surface area of the first cylinder is:cout The surface area of the first cylinder is:t t cylinder1.surface_area()endl;cylinder1.surface_area()endl;co
80、ut The radius of the second cylinder is:cout The radius of the second cylinder is:t cylinder2.getradius()endl;t cylinder2.getradius()endl;cout The height of the second cylinder is:cout The height of the second cylinder is:t cylinder2.getheight()endl;t cylinder2.getheight()endl;cout The volume of the
81、 second cylinder is:cout The volume of the second cylinder is:t cylinder2.volume()endl;t cylinder2.volume()endl;cout The surface area of the second cylinder is:cout The surface area of the second cylinder is:t t cylinder2.surface_area()endl;cylinder2.surface_area()endl; 第第第第2 2部分部分部分部分系统在创建每一个对象时都需要
82、系统在创建每一个对象时都需要系统在创建每一个对象时都需要系统在创建每一个对象时都需要自动调用相应的构造函数。自动调用相应的构造函数。自动调用相应的构造函数。自动调用相应的构造函数。其形式如下：其形式如下：其形式如下：其形式如下：类名：类名（）类名：类名（）类名：类名（）类名：类名（） （续）（续）（续）（续） /EXAMPLE3_13.H/EXAMPLE3_13.H#include#includeclass Aclass A public:public: A() A() coutA() is calledendl; coutA() is calledendl; A(int x,int y);
83、A(int x,int y);private:private: int a,b; int a,b; ;A:A(int x,int y)A:A(int x,int y) a=x; a=x; b=y; b=y; coutA(int x,int y) is calledendl; coutA(int x,int y) is calledendl; coutA=a coutA=atB=bendl;tB=bendl; 构造函数的调用构造函数的调用构造函数的调用构造函数的调用例例例例 3-13 3-13 3-13 3-13A() is calledA() is calledA(int x,int y) i
84、s calledA(int x,int y) is calledA=10 B=10A=10 B=10/EXAMPLE3_13.CPP/EXAMPLE3_13.CPP#includeEXAMPLE3_13.H#includeEXAMPLE3_13.Hvoid main()void main() A a; A a; A b(10,10); A b(10,10); C+C+类中还有一个类中还有一个类中还有一个类中还有一个特殊的成员函数特殊的成员函数特殊的成员函数特殊的成员函数，即析构函数。，即析构函数。，即析构函数。，即析构函数。析构函数析构函数析构函数析构函数在对象终止时由在对象终止时由在对象终止
85、时由在对象终止时由系统自动调用，以释放分配给对象的内存。析构函数的函数名应为类名前加系统自动调用，以释放分配给对象的内存。析构函数的函数名应为类名前加系统自动调用，以释放分配给对象的内存。析构函数的函数名应为类名前加系统自动调用，以释放分配给对象的内存。析构函数的函数名应为类名前加“ “” ”，析构函数中没有参数，也不能为之指定返回值类型。析构函数中没有参数，也不能为之指定返回值类型。析构函数中没有参数，也不能为之指定返回值类型。析构函数中没有参数，也不能为之指定返回值类型。注注注注一个类内只能声明一个析构函数一个类内只能声明一个析构函数一个类内只能声明一个析构函数一个类内只能声明一个析构函数
86、。它也是。它也是。它也是。它也是公有的成员函数公有的成员函数公有的成员函数公有的成员函数。如果类中。如果类中。如果类中。如果类中没有声明，编译器也会自动生成一个没有声明，编译器也会自动生成一个没有声明，编译器也会自动生成一个没有声明，编译器也会自动生成一个带空函数体的析构函数带空函数体的析构函数带空函数体的析构函数带空函数体的析构函数。【 3.4.2 3.4.2 析构函数析构函数析构函数析构函数】析构函数的执行过程析构函数的执行过程析构函数的执行过程析构函数的执行过程/EXAMPLE3_14.H/EXAMPLE3_14.H#include#includeclass Aclass A publi
87、c:public: A() A() coutA() is calledendl; coutA() is calledendl; A()A() cout coutA() is calledendl;A() is calledendl; ; ;/EXAMPLE3_14.CPP/EXAMPLE3_14.CPP#includeEXAMPLE3_14.H#includeEXAMPLE3_14.Hvoid main()void main() A a; A a; coutthe program will endendl; coutthe program will endendl; A() is called
88、A() is calledThe program wiil endThe program wiil endA() is calledA() is called例例例例 3-14 3-14 3-14 3-14以其他类对象作为数据成员的类，称为以其他类对象作为数据成员的类，称为以其他类对象作为数据成员的类，称为以其他类对象作为数据成员的类，称为组合类组合类组合类组合类。在声明组合类的对象时，类中的内嵌对象也将被自动创建。创建这种类的对在声明组合类的对象时，类中的内嵌对象也将被自动创建。创建这种类的对在声明组合类的对象时，类中的内嵌对象也将被自动创建。创建这种类的对在声明组合类的对象时，类中的内嵌对
89、象也将被自动创建。创建这种类的对象时，为了初始化内嵌对象，需要调用这些内嵌对象所属类的构造函数。象时，为了初始化内嵌对象，需要调用这些内嵌对象所属类的构造函数。象时，为了初始化内嵌对象，需要调用这些内嵌对象所属类的构造函数。象时，为了初始化内嵌对象，需要调用这些内嵌对象所属类的构造函数。组合类的构造函数应定义成如下形式：组合类的构造函数应定义成如下形式：组合类的构造函数应定义成如下形式：组合类的构造函数应定义成如下形式： 类名：类名（形参表）：对象类名：类名（形参表）：对象类名：类名（形参表）：对象类名：类名（形参表）：对象1 1（形参表），对象（形参表），对象（形参表），对象（形参表），对象
90、2 2（形参表），（形参表），（形参表），（形参表），对象，对象，对象，对象n n（形参表）（形参表）（形参表）（形参表） 函数体函数体函数体函数体 /EXAMPLE315.H/EXAMPLE315.H#include#includeclass Aclass A public: public: A (int x) / A (int x) /构造函数构造函数构造函数构造函数 ( (续续续续) )例例例例 3-15 3-15 3-15 3-15组合类对象的初始化过程组合类对象的初始化过程组合类对象的初始化过程组合类对象的初始化过程一个标点符号，其后的一个标点符号，其后的一个标点符号，其后的一个标点
91、符号，其后的列表叫成员初始化列表列表叫成员初始化列表列表叫成员初始化列表列表叫成员初始化列表对象对象对象对象1 1、对象、对象、对象、对象2 2、，对，对，对，对象象象象n n就是类的内嵌对象就是类的内嵌对象就是类的内嵌对象就是类的内嵌对象【 3.5 3.5 类的组合类的组合类的组合类的组合】 a=x; a=x; cout class A constructing cout class A constructing t tt aendl;t aendl; A () /A () /析构函数析构函数析构函数析构函数 cout class A destructing endl; cout class
92、 A destructing endl; private: private: int a; int a; ; ; class B class B public: public: B() / B() /构造函数构造函数构造函数构造函数 cout class B constructing and data member is not evaluatedendl; cout class B constructing and data member is not evaluatedendl; B(int x) / B(int x) /构造函数构造函数构造函数构造函数 b=x; b=x; cout cl
93、ass B constructing cout class B constructing t tt bendl;t bendl;组合类对象的初始化过程组合类对象的初始化过程组合类对象的初始化过程组合类对象的初始化过程例例例例 3-15 3-15 3-15 3-15B() /B() /析构函数析构函数析构函数析构函数 cout class B destructing endl; cout class B destructing endl; private: private: int b; int b; ;class Cclass C public: public: C(int x,int y):
94、a1(y) / C(int x,int y):a1(y) /构造函数构造函数构造函数构造函数 c=x; c=x; cout class C constructing without object b1 is not evaluated ; cout class C constructing without object b1 is not evaluated ; cout cout t tt cendl;t cendl; C(int x,int a,int b ); / C(int x,int a,int b ); /构造函数构造函数构造函数构造函数 C() /C() /析构函数析构函数析构函
95、数析构函数 cout class C destructing endl; cout class C destructing endl; 一个的初始化成员列表中只有对象一个的初始化成员列表中只有对象一个的初始化成员列表中只有对象一个的初始化成员列表中只有对象a1a1，这是因为内嵌对象，这是因为内嵌对象，这是因为内嵌对象，这是因为内嵌对象b1b1所属的类所属的类所属的类所属的类B B中有中有中有中有一个不需要参数的构造函数，所以可一个不需要参数的构造函数，所以可一个不需要参数的构造函数，所以可一个不需要参数的构造函数，所以可以不给以不给以不给以不给b1b1提供初始化数据。在这种情提供初始化数据。在
96、这种情提供初始化数据。在这种情提供初始化数据。在这种情况下无参数的构造函数将被调用。况下无参数的构造函数将被调用。况下无参数的构造函数将被调用。况下无参数的构造函数将被调用。（续）（续）（续）（续）private:private: int c; int c; A a1; A a1; B b1; B b1; ;/EXAMPLE315.CPP/EXAMPLE315.CPP#includeEXAMPLE315.H#includeEXAMPLE315.HC:C (int x,int a,int b ):b1(a),a1(b) /C:C (int x,int a,int b ):b1(a),a1(b)
97、/定义构造函数定义构造函数定义构造函数定义构造函数 c=x;c=x;cout class C constructingcout class C constructingt tt cendl;t cendl; void main()void main() C c1(2,3);C c1(2,3);cout Object c1 of class C has been created endl;cout Object c1 of class C has been created endl;C c2(10,20,30);C c2(10,20,30);cout Object c2 of class C h
98、as been created endl;cout Object c2 of class C has been created endl;cout Destroy them endl;cout Destroy them endl; （续）（续）（续）（续）class A constructing 3class A constructing 3class B constructing and data member is not evaluatedclass B constructing and data member is not evaluatedclass C constructing w
99、ithout object b1 is not evaluated 2class C constructing without object b1 is not evaluated 2Object c1 of class C has been createdObject c1 of class C has been createdclass A constructing 20class A constructing 20class B constructing 30class B constructing 30class C constructing 10class C constructin
100、g 10Object c2 of class C has been createdObject c2 of class C has been createdDestroy themDestroy themClass C destructingClass C destructingClass B destructingClass B destructingClass A destructingClass A destructingClass C destructingClass C destructingClass B destructingClass B destructingClass A
101、destructingClass A destructing 在创建组合类的对象时，将按内嵌对象在类中声明的先后顺序，而在创建组合类的对象时，将按内嵌对象在类中声明的先后顺序，而在创建组合类的对象时，将按内嵌对象在类中声明的先后顺序，而在创建组合类的对象时，将按内嵌对象在类中声明的先后顺序，而不是按成员初始化列表中的顺序不是按成员初始化列表中的顺序不是按成员初始化列表中的顺序不是按成员初始化列表中的顺序，调用其相应构造函数，最后调用该组合，调用其相应构造函数，最后调用该组合，调用其相应构造函数，最后调用该组合，调用其相应构造函数，最后调用该组合类的构造函数。而类的构造函数。而类的构造函数。而类
102、的构造函数。而析构函数的调用顺序相反析构函数的调用顺序相反析构函数的调用顺序相反析构函数的调用顺序相反。注注注注（续）（续）（续）（续）只有在定义构造函数时只有在定义构造函数时只有在定义构造函数时只有在定义构造函数时，才可以，才可以，才可以，才可以带有成员初始化列表带有成员初始化列表带有成员初始化列表带有成员初始化列表。如果仅仅是声明构。如果仅仅是声明构。如果仅仅是声明构。如果仅仅是声明构造函数原型，则造函数原型，则造函数原型，则造函数原型，则不能带成员初始化列表不能带成员初始化列表不能带成员初始化列表不能带成员初始化列表。成员初始化列表可用于初始化类中的普通数据成员。甚至还是成员初始化列表可
103、用于初始化类中的普通数据成员。甚至还是成员初始化列表可用于初始化类中的普通数据成员。甚至还是成员初始化列表可用于初始化类中的普通数据成员。甚至还是必须的必须的必须的必须的（如（如（如（如后面将介绍的常数据成员等）。后面将介绍的常数据成员等）。后面将介绍的常数据成员等）。后面将介绍的常数据成员等）。class Aclass A public: public: A (int x):a(x) A (int x):a(x) cout class A constructing cout class A constructingt tt aendl;t aendl; A ()A () cout class
104、 A destructing endl; cout class A destructing endl; private: private: int a; int a; ;例如，【例例如，【例例如，【例例如，【例3 3 - - - - 15 15】中】中】中】中类类类类A A的声明的声明的声明的声明就可以改为如下形式：就可以改为如下形式：就可以改为如下形式：就可以改为如下形式：静态成员静态成员静态成员静态成员是满足在某些情况下数据共享的需求。是满足在某些情况下数据共享的需求。是满足在某些情况下数据共享的需求。是满足在某些情况下数据共享的需求。静态数据成员静态数据成员静态数据成员静态数据成员是同一
105、个类中所有对象共享的成员，而不是某一对象的成是同一个类中所有对象共享的成员，而不是某一对象的成是同一个类中所有对象共享的成员，而不是某一对象的成是同一个类中所有对象共享的成员，而不是某一对象的成员。一个类的静态数据成员只存储在一处，员。一个类的静态数据成员只存储在一处，员。一个类的静态数据成员只存储在一处，员。一个类的静态数据成员只存储在一处，供该类所有对象共享访问供该类所有对象共享访问供该类所有对象共享访问供该类所有对象共享访问。静态成员的分类静态成员的分类静态成员的分类静态成员的分类静态数据成员静态数据成员静态数据成员静态数据成员静态成员函数静态成员函数静态成员函数静态成员函数【 3.6.
106、1 3.6.1 静态数据成员静态数据成员静态数据成员静态数据成员】如果需要把某一数据成员声明为静态成员，只需在其前面如果需要把某一数据成员声明为静态成员，只需在其前面如果需要把某一数据成员声明为静态成员，只需在其前面如果需要把某一数据成员声明为静态成员，只需在其前面加关键字加关键字加关键字加关键字staticstatic。由于静态数据成员是静态存储的，它具有由于静态数据成员是静态存储的，它具有由于静态数据成员是静态存储的，它具有由于静态数据成员是静态存储的，它具有静态生存期静态生存期静态生存期静态生存期。注注注注 由于在声明类时说明的静态数据成员只是一种引用性声明，而且在声由于在声明类时说明的
107、静态数据成员只是一种引用性声明，而且在声由于在声明类时说明的静态数据成员只是一种引用性声明，而且在声由于在声明类时说明的静态数据成员只是一种引用性声明，而且在声明对象时，由于静态数据成员的特殊性，明对象时，由于静态数据成员的特殊性，明对象时，由于静态数据成员的特殊性，明对象时，由于静态数据成员的特殊性，并不会为之分配内存并不会为之分配内存并不会为之分配内存并不会为之分配内存。要求。要求。要求。要求单独对单独对单独对单独对静态数据成员进行定义性声明静态数据成员进行定义性声明静态数据成员进行定义性声明静态数据成员进行定义性声明，以获得相应的存储空间。，以获得相应的存储空间。，以获得相应的存储空间。
108、，以获得相应的存储空间。【 3.6 3.6 静态成员静态成员静态成员静态成员】必须在具有文件作用域的某个地方进行。必须在具有文件作用域的某个地方进行。必须在具有文件作用域的某个地方进行。必须在具有文件作用域的某个地方进行。其形式如下：其形式如下：其形式如下：其形式如下： 类型类型类型类型 类名：静态数据成员名；类名：静态数据成员名；类名：静态数据成员名；类名：静态数据成员名；注注注注在定义静态数据成员时，由于关键字在定义静态数据成员时，由于关键字在定义静态数据成员时，由于关键字在定义静态数据成员时，由于关键字staticstatic不是数据类型的一部不是数据类型的一部不是数据类型的一部不是数据
109、类型的一部分，不能加。分，不能加。分，不能加。分，不能加。 静态数据成员的使用静态数据成员的使用静态数据成员的使用静态数据成员的使用/EXAMPLE3_16.H/EXAMPLE3_16.H#includeiostream.h#includeiostream.hclass Aclass A public:public: A(int x,int y) A(int x,int y) a=x; a=x; b=y; b=y; A()A() void getXY() void getXY() 例例例例 3-16 3-16 3-16 3-16 cout X= a cout X= a t Y= bendl;
110、t Y= bendl; void getSUM() void getSUM() sum=sum+a+b; sum=sum+a+b; cout SUM= sumendl; cout SUM= sumendl; private:private: int a,b; int a,b; static int sum; static int sum; ;int A:sum=0; /int A:sum=0; /静态数据成员的定义静态数据成员的定义静态数据成员的定义静态数据成员的定义/EXAMPLE3_16.CPP/EXAMPLE3_16.CPP#includeEXAMPLE3_16.Hvoid main()
111、#includeEXAMPLE3_16.Hvoid main() A a1(1,2);A a1(1,2);a1.getXY();a1.getXY();a1.getSUM();a1.getSUM();A a2(3,4);A a2(3,4);a2.getXY();a2.getXY();a2.getSUM();a2.getSUM(); X=1 Y=2X=1 Y=2SUM=3SUM=3X=3 Y=4X=3 Y=4SUM=10SUM=10（续）（续）（续）（续）例如：例如：例如：例如： #include#include class A class A public: public: static int
112、 x;static int x; ;int A:x=0;int A:x=0;void main()void main() coutA:xendl;coutA:xendl;A:x=10;A:x=10;coutA:xendl;coutA:xendl; 在声明类时，让静态数据成员公有，则程序中可以在声明类时，让静态数据成员公有，则程序中可以在声明类时，让静态数据成员公有，则程序中可以在声明类时，让静态数据成员公有，则程序中可以不通过该类的对象直接不通过该类的对象直接不通过该类的对象直接不通过该类的对象直接访问该数据访问该数据访问该数据访问该数据。对它的访问可以直接通过类名实现。对它的访问可以直接通过
113、类名实现。对它的访问可以直接通过类名实现。对它的访问可以直接通过类名实现。对于把类的静态数据成员对于把类的静态数据成员对于把类的静态数据成员对于把类的静态数据成员声明为私有声明为私有声明为私有声明为私有的情形，如果希望的情形，如果希望的情形，如果希望的情形，如果希望不使用该类的对象不使用该类的对象不使用该类的对象不使用该类的对象来访问该数据来访问该数据来访问该数据来访问该数据，就必须据访问该数据的公有辅助成员函数声明为，就必须据访问该数据的公有辅助成员函数声明为，就必须据访问该数据的公有辅助成员函数声明为，就必须据访问该数据的公有辅助成员函数声明为静态的静态的静态的静态的，也即必须提供访问它的
114、公有静态成员函数。也即必须提供访问它的公有静态成员函数。也即必须提供访问它的公有静态成员函数。也即必须提供访问它的公有静态成员函数。形式如下：形式如下：形式如下：形式如下： 类名：静态数据成员名类名：静态数据成员名类名：静态数据成员名类名：静态数据成员名如果声明类时，在其中的某个成员函数的类型前加上关键字如果声明类时，在其中的某个成员函数的类型前加上关键字如果声明类时，在其中的某个成员函数的类型前加上关键字如果声明类时，在其中的某个成员函数的类型前加上关键字staticstatic，则这个，则这个，则这个，则这个成员函数就是成员函数就是成员函数就是成员函数就是静态成员函数静态成员函数静态成员函
115、数静态成员函数。定义静态函数成员定义静态函数成员定义静态函数成员定义静态函数成员也是解决在同一个类的所有也是解决在同一个类的所有也是解决在同一个类的所有也是解决在同一个类的所有对象之间对象之间对象之间对象之间共享数据共享数据共享数据共享数据的方法之一。的方法之一。的方法之一。的方法之一。在静态成员函数的函数体中，可以在静态成员函数的函数体中，可以在静态成员函数的函数体中，可以在静态成员函数的函数体中，可以直接访问直接访问直接访问直接访问所属类的静态成员，所属类的静态成员，所属类的静态成员，所属类的静态成员，不能直接访不能直接访不能直接访不能直接访问问问问非静态成员。要非静态成员。要非静态成员。
116、要非静态成员。要访问非静态成员访问非静态成员访问非静态成员访问非静态成员，须借助于对象名或指向对象的指针。，须借助于对象名或指向对象的指针。，须借助于对象名或指向对象的指针。，须借助于对象名或指向对象的指针。注注注注在类外定义静态成员函数，函数头前不能加关键字在类外定义静态成员函数，函数头前不能加关键字在类外定义静态成员函数，函数头前不能加关键字在类外定义静态成员函数，函数头前不能加关键字staticstatic。例例例例 3-17 3-17 3-17 3-17 静态成员函数的使用静态成员函数的使用静态成员函数的使用静态成员函数的使用/EXAMPLE3_17.H/EXAMPLE3_17.H#i
117、nclude#includeclass Aclass A public:public: A(int x1 A(int x1，int x2)int x2) x=x1; x=x1;【 3.6.2 3.6.2 静态成员函数静态成员函数静态成员函数静态成员函数】 y=y+x2; y=y+x2; A()A() static void fun1(); static void fun1(); static void fun2(A a); static void fun2(A a);private:private: int x; int x; static int y; static int y; ;/EXA
118、MPLE3_17.CPP/EXAMPLE3_17.CPP#includeEXAMPLE3_17.H#includeEXAMPLE3_17.Hvoid A:fun1()void A:fun1() cout Y= yendl; / cout Y= yendl; /直接访问静态数据成员直接访问静态数据成员直接访问静态数据成员直接访问静态数据成员 void A:fun2(A a)void A:fun2(A a) cout X= a.x cout X= a.x t Y= yendl; /t Y= yendl; /对非静态成员，对非静态成员，对非静态成员，对非静态成员，通过对象名访问通过对象名访问通过对象
119、名访问通过对象名访问 静态成员函数的使用静态成员函数的使用静态成员函数的使用静态成员函数的使用例例例例 3-17 3-17 3-17 3-17 int A:y=0; int A:y=0; void main()void main() A a1(1,2); A a1(1,2);a1.fun1(); /a1.fun1(); /通过对象名访问通过对象名访问通过对象名访问通过对象名访问A:fun2(a1); /A:fun2(a1); /通过类名访问通过类名访问通过类名访问通过类名访问A a2(3,4);A a2(3,4);A:fun1(); /A:fun1(); /通过类名访问通过类名访问通过类名访问
120、通过类名访问a2.fun2(a2); /a2.fun2(a2); /通过对象名访问通过对象名访问通过对象名访问通过对象名访问 Y=2Y=2X=1 Y=2X=1 Y=2Y=6Y=6X=3 Y=6X=3 Y=6公有的静态成员函数公有的静态成员函数公有的静态成员函数公有的静态成员函数也可以通过相应的对象名来访问。公有静态成也可以通过相应的对象名来访问。公有静态成也可以通过相应的对象名来访问。公有静态成也可以通过相应的对象名来访问。公有静态成员函数还可以通过其所属的类名来访问。员函数还可以通过其所属的类名来访问。员函数还可以通过其所属的类名来访问。员函数还可以通过其所属的类名来访问。静态成员函数不能声
121、明为静态成员函数不能声明为静态成员函数不能声明为静态成员函数不能声明为常成员函数常成员函数常成员函数常成员函数。注注注注（续）（续）（续）（续）友元友元友元友元提供了在不同类的成员函数之间、类的成员函数与一般函数之间进行提供了在不同类的成员函数之间、类的成员函数与一般函数之间进行提供了在不同类的成员函数之间、类的成员函数与一般函数之间进行提供了在不同类的成员函数之间、类的成员函数与一般函数之间进行数据共享的机制。数据共享的机制。数据共享的机制。数据共享的机制。通过友元通过友元通过友元通过友元，一个普通函数或另一个类中的成员函数可以，一个普通函数或另一个类中的成员函数可以，一个普通函数或另一个类
122、中的成员函数可以，一个普通函数或另一个类中的成员函数可以访问类中的私有成员和保护成员。访问类中的私有成员和保护成员。访问类中的私有成员和保护成员。访问类中的私有成员和保护成员。友元友元友元友元可以是函数，则该函数叫可以是函数，则该函数叫可以是函数，则该函数叫可以是函数，则该函数叫友元函数。友元函数。友元函数。友元函数。可以是一个类，则该类叫可以是一个类，则该类叫可以是一个类，则该类叫可以是一个类，则该类叫友元类。友元类。友元类。友元类。在声明一个类时，可以使用关键字在声明一个类时，可以使用关键字在声明一个类时，可以使用关键字在声明一个类时，可以使用关键字friendfriend把一个函数声明为
123、把一个函数声明为把一个函数声明为把一个函数声明为这个类的友元函这个类的友元函这个类的友元函这个类的友元函数。数。数。数。【 3.7.1 3.7.1 友元函数友元函数友元函数友元函数】友元函数并不是这个类的成员函数，但它可以在其函数体中友元函数并不是这个类的成员函数，但它可以在其函数体中友元函数并不是这个类的成员函数，但它可以在其函数体中友元函数并不是这个类的成员函数，但它可以在其函数体中通过通过通过通过对象名访问对象名访问对象名访问对象名访问这个类的私有或保护成员。这个类的私有或保护成员。这个类的私有或保护成员。这个类的私有或保护成员。注注注注例例例例 3-18 3-18 3-18 3-18友
124、元函数的使用友元函数的使用友元函数的使用友元函数的使用/EXAMPLE3_18.H/EXAMPLE3_18.H#include#include【 3.7 3.7 友元友元友元友元】class A /class A /声明类声明类声明类声明类A A public:public: void memberfun (int x); void memberfun (int x); ;class B /class B /声明类声明类声明类声明类B B public:public: B() B() B(int x1) B(int x1) x=x1; x=x1; B()B() void getX() void
125、 getX() cout X= xendl; cout X= xendl; friend void fun(); /friend void fun(); /友元函数友元函数友元函数友元函数friend void A:memberfun(int x); /friend void A:memberfun(int x); /友元函数友元函数友元函数友元函数private:private:友元函数的使用友元函数的使用友元函数的使用友元函数的使用例例例例 3-18 3-18 3-18 3-18int x; int x; ; ;/EXAMPLE3_18.CPP/EXAMPLE3_18.CPP#includ
126、eEXAMPLE3_18.H#includeEXAMPLE3_18.Hvoid A:memberfun(int x)void A:memberfun(int x) B b(0)B b(0)cout X= b.xendl;cout X= b.xendl;b.x=x;b.x=x;cout X= b.xendl;cout X= b.xendl; void fun()void fun() B b(10);B b(10);cout X= b.xendl;cout X= b.xendl; void main()void main() fun();fun();A a;A a;a.memberfun(100)
127、;a.memberfun(100); X=10X=10X=0X=0X=100X=100（续）（续）（续）（续）如果需要把一个类（设为如果需要把一个类（设为如果需要把一个类（设为如果需要把一个类（设为A A）中的所有成员函数都声明为另一个类（设为）中的所有成员函数都声明为另一个类（设为）中的所有成员函数都声明为另一个类（设为）中的所有成员函数都声明为另一个类（设为B B）的）的）的）的友元函数友元函数友元函数友元函数，则不必在类，则不必在类，则不必在类，则不必在类B B中对类中对类中对类中对类A A中的成员函数一一加以说明。中的成员函数一一加以说明。中的成员函数一一加以说明。中的成员函数一一加以
128、说明。直接把类直接把类直接把类直接把类A A声明为类声明为类声明为类声明为类B B的友元，这时称的友元，这时称的友元，这时称的友元，这时称类类类类A A为类为类为类为类B B的友元类。的友元类。的友元类。的友元类。简述简述简述简述友元声明也可以出现在类的私有或保护部分。友元声明也可以出现在类的私有或保护部分。友元声明也可以出现在类的私有或保护部分。友元声明也可以出现在类的私有或保护部分。具体的说明形式如下：具体的说明形式如下：具体的说明形式如下：具体的说明形式如下： class Aclass A . .; ;class Bclass B . .friend class A;friend cla
129、ss A;. .; ;注意事项：注意事项：注意事项：注意事项： 友元关系友元关系友元关系友元关系不具有交换性不具有交换性不具有交换性不具有交换性，也即友元关，也即友元关，也即友元关，也即友元关 系具有单向的。若声明类系具有单向的。若声明类系具有单向的。若声明类系具有单向的。若声明类A A为类为类为类为类B B的友的友的友的友 元，并不表示类元，并不表示类元，并不表示类元，并不表示类B B就是类就是类就是类就是类A A的友元。的友元。的友元。的友元。 友元关系友元关系友元关系友元关系不具有传递性不具有传递性不具有传递性不具有传递性，即若声明类，即若声明类，即若声明类，即若声明类 A A为类为类为
130、类为类B B的友元，类的友元，类的友元，类的友元，类B B为类为类为类为类C C的友元，的友元，的友元，的友元， 并不表示类并不表示类并不表示类并不表示类A A就是类就是类就是类就是类C C的友元。的友元。的友元。的友元。【 3.7.2 3.7.2 友元类友元类友元类友元类】常对象的声明需要采用关键字常对象的声明需要采用关键字常对象的声明需要采用关键字常对象的声明需要采用关键字constconst，形式如下：，形式如下：，形式如下：，形式如下： 类名类名类名类名 const const 对象名对象名对象名对象名 或或或或 const const 类名类名类名类名 对象名对象名对象名对象名例如：
131、例如：例如：例如： class Aclass A public: public: A(int i,int j); A(int i,int j); . .private:private: int a,b; int a,b; A:A(int i,int j)A:A(int i,int j) a=i; a=i; b=j; b=j; A const a(1,2);A const a(1,2);const A b(3,4); const A b(3,4); 说明：说明：说明：说明：声明常对象时声明常对象时声明常对象时声明常对象时同时同时同时同时初始化，初始化，初始化，初始化，并该对象在程序的其他地方并该
132、对象在程序的其他地方并该对象在程序的其他地方并该对象在程序的其他地方不能不能不能不能被重新赋值被重新赋值被重新赋值被重新赋值。 这里声明的这里声明的这里声明的这里声明的a a和和和和b b都是常对象，都是常对象，都是常对象，都是常对象，其值不可改变。其值不可改变。其值不可改变。其值不可改变。【3.8 3.8 常对象、常成员函数与常数据成员常对象、常成员函数与常数据成员常对象、常成员函数与常数据成员常对象、常成员函数与常数据成员】类的数据成员类的数据成员类的数据成员类的数据成员如果其值在程序运行过程中不改变，也可以声明为常量。被如果其值在程序运行过程中不改变，也可以声明为常量。被如果其值在程序运
133、行过程中不改变，也可以声明为常量。被如果其值在程序运行过程中不改变，也可以声明为常量。被声明为常量的类的数据成员称作声明为常量的类的数据成员称作声明为常量的类的数据成员称作声明为常量的类的数据成员称作常数据成员常数据成员常数据成员常数据成员。例例例例 3-19 3-19 3-19 3-19常数据成员的使用常数据成员的使用常数据成员的使用常数据成员的使用/EXAMPLE3_19.H/EXAMPLE3_19.H#include#includeclass Aclass A public: public: A (int x,int y):a(x),c(y) / A (int x,int y):a(x)
134、,c(y) /常数据成员只能通过初始化列表来初始化常数据成员只能通过初始化列表来初始化常数据成员只能通过初始化列表来初始化常数据成员只能通过初始化列表来初始化 A ()A () void getAB() void getAB() 声明形式和一般符号常量声明形式和一般符号常量声明形式和一般符号常量声明形式和一般符号常量采用关键字采用关键字采用关键字采用关键字constconst声明的形式一样声明的形式一样声明的形式一样声明的形式一样。不不不不能在类内声明能在类内声明能在类内声明能在类内声明这些常数据成员时直接赋初值，而这些常数据成员时直接赋初值，而这些常数据成员时直接赋初值，而这些常数据成员时直
135、接赋初值，而只能通过编写只能通过编写只能通过编写只能通过编写带有初始化带有初始化带有初始化带有初始化列表的构造函数来列表的构造函数来列表的构造函数来列表的构造函数来初始化初始化初始化初始化。简述简述简述简述【 3.8.2 3.8.2 常数据成员常数据成员常数据成员常数据成员】A=1 B=10 C=2A=1 B=10 C=2 void getAB() void getAB() cout A= a cout A= a t B= b t B= b t C= cendl;t C= cendl; private: private: const int a; const int a; static con
136、st int b; static const int b; int c; int c; ;/EXAMPLE3_19.CPP/EXAMPLE3_19.CPP#includeEXAMPLE3_19.H#includeEXAMPLE3_19.Hconst int A:b=10; /const int A:b=10; /静态常数据成员在类外定义并初始化静态常数据成员在类外定义并初始化静态常数据成员在类外定义并初始化静态常数据成员在类外定义并初始化void main()void main() A a(1,2); A a(1,2); a.getAB();a.getAB(); 常数据成员的使用常数据成员的使
137、用常数据成员的使用常数据成员的使用例例例例 3-19 3-19 3-19 3-19使用关键字使用关键字使用关键字使用关键字constconst修饰的成员函数叫作常成员函数，关键字修饰的成员函数叫作常成员函数，关键字修饰的成员函数叫作常成员函数，关键字修饰的成员函数叫作常成员函数，关键字constconst应放在函数应放在函数应放在函数应放在函数参数表的括号之后。参数表的括号之后。参数表的括号之后。参数表的括号之后。形式如下：形式如下：形式如下：形式如下： 类型类型类型类型 函数名（参数表）函数名（参数表）函数名（参数表）函数名（参数表） const const类的常成员函数类的常成员函数类的常
138、成员函数类的常成员函数不能改变成员变量的值，也不能调用该类中没有不能改变成员变量的值，也不能调用该类中没有不能改变成员变量的值，也不能调用该类中没有不能改变成员变量的值，也不能调用该类中没有constconst修饰修饰修饰修饰的成员函数。的成员函数。的成员函数。的成员函数。静态成员函数不能声明为常成员函数。静态成员函数不能声明为常成员函数。静态成员函数不能声明为常成员函数。静态成员函数不能声明为常成员函数。例例例例 3-20 3-20 3-20 3-20常成员函数的使用常成员函数的使用常成员函数的使用常成员函数的使用/EXAMPLE3_20.H/EXAMPLE3_20.H#include#in
139、cludeclass Aclass A public: public: A (int x,int y) A (int x,int y) 关键字关键字关键字关键字constconst是函数类型的组成部分，在是函数类型的组成部分，在是函数类型的组成部分，在是函数类型的组成部分，在声明和定义这个函数时都声明和定义这个函数时都声明和定义这个函数时都声明和定义这个函数时都不能省去不能省去不能省去不能省去。【 3.8.3 3.8.3 常成员函数常成员函数常成员函数常成员函数】通过常对象通过常对象通过常对象通过常对象b b访问的是常成员访问的是常成员访问的是常成员访问的是常成员函数函数函数函数void ge
140、tAB() constvoid getAB() const通过对象通过对象通过对象通过对象a a访问的是普通成员访问的是普通成员访问的是普通成员访问的是普通成员函数函数函数函数void getAB()void getAB()例例例例 3-20 3-20 3-20 3-20 a=x; a=x; b=y; b=y; A ()A () void getAB(); void getAB(); void getAB() const; void getAB() const; private: private: int a; int a; int b; int b; ;/EXAMPLE3_20.CPP/EX
141、AMPLE3_20.CPP#includeEXAMPLE3_20.H#includeEXAMPLE3_20.Hvoid A:getAB()void A:getAB() cout In void A:getAB()endl;cout In void A:getAB()endl;cout A= a cout A= a t B= bendl;t B= bendl; void A:getAB() constvoid A:getAB() const 常成员函数的使用常成员函数的使用常成员函数的使用常成员函数的使用cout In void A:getAB() const endl;cout In void
142、 A:getAB() const endl;cout A= a cout A= a t B= bendl;t B= bMp-M这样的表达式中，其中这样的表达式中，其中这样的表达式中，其中这样的表达式中，其中p p是指向类是指向类是指向类是指向类A A的一的一的一的一 个对象的指针。个对象的指针。个对象的指针。个对象的指针。【 3.9.1 3.9.1 类作用域类作用域类作用域类作用域】类作用域类作用域类作用域类作用域是指在类的声明中用一对花括号括起来的部分。类中包含的成员是指在类的声明中用一对花括号括起来的部分。类中包含的成员是指在类的声明中用一对花括号括起来的部分。类中包含的成员是指在类的声明
143、中用一对花括号括起来的部分。类中包含的成员都具有类作用域都具有类作用域都具有类作用域都具有类作用域。类成员具有类作用域的一般条件：类成员具有类作用域的一般条件：类成员具有类作用域的一般条件：类成员具有类作用域的一般条件：【 3.9.2 3.9.2 对象生存期对象生存期对象生存期对象生存期】对象的生存期对象的生存期对象的生存期对象的生存期指的就是对象从创建到终止的这段时间。指的就是对象从创建到终止的这段时间。指的就是对象从创建到终止的这段时间。指的就是对象从创建到终止的这段时间。对于一般变量对于一般变量对于一般变量对于一般变量也存也存也存也存在着生存期问题。为了描述的方便，这里使用对象来在着生存
144、期问题。为了描述的方便，这里使用对象来在着生存期问题。为了描述的方便，这里使用对象来在着生存期问题。为了描述的方便，这里使用对象来统一表示类的对象和统一表示类的对象和统一表示类的对象和统一表示类的对象和一般变量。一般变量。一般变量。一般变量。【3.9 3.9 类的作用域及对象的生存期类的作用域及对象的生存期类的作用域及对象的生存期类的作用域及对象的生存期】如果当程序第一次声明对象时，该对象被创建，当程序结束运行时，对象如果当程序第一次声明对象时，该对象被创建，当程序结束运行时，对象如果当程序第一次声明对象时，该对象被创建，当程序结束运行时，对象如果当程序第一次声明对象时，该对象被创建，当程序结
145、束运行时，对象才终止，说对象才终止，说对象才终止，说对象才终止，说对象具有静态生存期具有静态生存期具有静态生存期具有静态生存期，即静态生存期与程序的运行期相同。，即静态生存期与程序的运行期相同。，即静态生存期与程序的运行期相同。，即静态生存期与程序的运行期相同。根据对象生存时间期限的不同分类根据对象生存时间期限的不同分类根据对象生存时间期限的不同分类根据对象生存时间期限的不同分类静态生存期静态生存期静态生存期静态生存期动态生存期动态生存期动态生存期动态生存期在文件作用域中声明的对象具有静态生存期，这种对象又称在文件作用域中声明的对象具有静态生存期，这种对象又称在文件作用域中声明的对象具有静态生
146、存期，这种对象又称在文件作用域中声明的对象具有静态生存期，这种对象又称全局对象。全局对象。全局对象。全局对象。例如：例如：例如：例如： #include #includeint i=0; /int i=0; /变量变量变量变量i i具有静态生存期，且具有文件作用域具有静态生存期，且具有文件作用域具有静态生存期，且具有文件作用域具有静态生存期，且具有文件作用域void main()void main() cout i= iendl;cout i= iendl; 需要在需要在需要在需要在某个小于文件作用域的作用域内某个小于文件作用域的作用域内某个小于文件作用域的作用域内某个小于文件作用域的作用域内
147、声明具有静态生存期的对象，就需声明具有静态生存期的对象，就需声明具有静态生存期的对象，就需声明具有静态生存期的对象，就需要在声明对象的语句中加上关键字要在声明对象的语句中加上关键字要在声明对象的语句中加上关键字要在声明对象的语句中加上关键字staticstatic，用这种方法声明的对象又称，用这种方法声明的对象又称，用这种方法声明的对象又称，用这种方法声明的对象又称静态静态静态静态对象对象对象对象。1. 1. 静态生存期静态生存期静态生存期静态生存期除了上述情况除了上述情况除了上述情况除了上述情况，在程序中声明的对象都具有动态生存期。这种对象都是在，在程序中声明的对象都具有动态生存期。这种对象
148、都是在，在程序中声明的对象都具有动态生存期。这种对象都是在，在程序中声明的对象都具有动态生存期。这种对象都是在小于文件作用域的范围内声明的，故又称为小于文件作用域的范围内声明的，故又称为小于文件作用域的范围内声明的，故又称为小于文件作用域的范围内声明的，故又称为局部生存期对象局部生存期对象局部生存期对象局部生存期对象（简称局部对（简称局部对（简称局部对（简称局部对象）。象）。象）。象）。例如：例如：例如：例如： void fun() void fun() static int I=0; /static int I=0; /变量变量变量变量I I具有静态生存期，但其可见性是局部的具有静态生存期，
149、但其可见性是局部的具有静态生存期，但其可见性是局部的具有静态生存期，但其可见性是局部的. . 这种对象的动态生存期始于对象声明处，终止于该对象作用域结束处。这种对象的动态生存期始于对象声明处，终止于该对象作用域结束处。这种对象的动态生存期始于对象声明处，终止于该对象作用域结束处。这种对象的动态生存期始于对象声明处，终止于该对象作用域结束处。例例例例 3-21 3-21 3-21 3-21具有静态、动态生存期对象的程序举例具有静态、动态生存期对象的程序举例具有静态、动态生存期对象的程序举例具有静态、动态生存期对象的程序举例/EXAMPLE3_21.H/EXAMPLE3_21.H#include#
150、include在小于文件作用域的作用域为声明的，具有静态生存期的变量，在小于文件作用域的作用域为声明的，具有静态生存期的变量，在小于文件作用域的作用域为声明的，具有静态生存期的变量，在小于文件作用域的作用域为声明的，具有静态生存期的变量，其可见性是其可见性是其可见性是其可见性是局部的局部的局部的局部的。并不具有文件作用域并不具有文件作用域并不具有文件作用域并不具有文件作用域。简述简述简述简述2. 2. 动态生存期动态生存期动态生存期动态生存期例例例例 3-21 3-21 3-21 3-21class Dateclass Date public:public: Date(int y=2001,i
151、nt m=1,int d=1); Date(int y=2001,int m=1,int d=1); Date()Date() void setDate(int y,int m,int d); void setDate(int y,int m,int d); void showDate() const; void showDate() const;private:private: int year,month,day; int year,month,day; ;/EXAMPLE3_21.CPP/EXAMPLE3_21.CPP#includeEXAMPLE3_21.H#includeEXAMPL
152、E3_21.HDate:Date(int y,int m,int d)Date:Date(int y,int m,int d) year=y; year=y; month=m; month=m; day=d; day=d; void Date:setDate(int y,int m,int d)void Date:setDate(int y,int m,int d) 具有静态、动态生存期对象的程序举例具有静态、动态生存期对象的程序举例具有静态、动态生存期对象的程序举例具有静态、动态生存期对象的程序举例 year=y; year=y; month=m; month=m; day=d; day=d
153、; void Date:setDate(int y,int m,int d)void Date:setDate(int y,int m,int d) year=y; year=y; month=m; month=m; day=d; day=d; void Date:showDate() constvoid Date:showDate() const coutyear coutyear年年年年monthmonth月月月月dayday日日日日endl;endl; Date date1(2001,1,1); /date1Date date1(2001,1,1); /date1具有静态生存期，文件作用
154、域具有静态生存期，文件作用域具有静态生存期，文件作用域具有静态生存期，文件作用域void main()void main() date1.showDate(); date1.showDate(); Date date2(2001,2,2); /date2 Date date2(2001,2,2); /date2具有动态生存期，块作用域具有动态生存期，块作用域具有动态生存期，块作用域具有动态生存期，块作用域 date2.showDate(); date2.showDate(); date2.setDate(2001,12,31); date2.setDate(2001,12,31); date2
155、.showDate(); date2.showDate();20012001年年年年1 1月月月月1 1日日日日20012001年年年年2 2月月月月2 2日日日日20012001年年年年1212月月月月3131日日日日（续）（续）（续）（续）在进行面向对象的程序设计过程中，可以在进行面向对象的程序设计过程中，可以在进行面向对象的程序设计过程中，可以在进行面向对象的程序设计过程中，可以利用图形把对问题的描述直观地利用图形把对问题的描述直观地利用图形把对问题的描述直观地利用图形把对问题的描述直观地表示出来表示出来表示出来表示出来。在使用图形时，必须准确而清晰地描述程序中的。在使用图形时，必须准确
156、而清晰地描述程序中的。在使用图形时，必须准确而清晰地描述程序中的。在使用图形时，必须准确而清晰地描述程序中的类、对象、类类、对象、类类、对象、类类、对象、类及对象的关系、类及对象之间的联系及对象的关系、类及对象之间的联系及对象的关系、类及对象之间的联系及对象的关系、类及对象之间的联系4 4个方面的问题。个方面的问题。个方面的问题。个方面的问题。介绍一种较为直观和简便的标记方法介绍一种较为直观和简便的标记方法介绍一种较为直观和简便的标记方法介绍一种较为直观和简便的标记方法-Coad/YourdonCoad/Yourdon标记。标记。标记。标记。它是由它是由它是由它是由Peter Peter Co
157、adCoad和和和和Ed YourdonEd Yourdon于于于于19901990年提出的。年提出的。年提出的。年提出的。标记分类标记分类标记分类标记分类表示表示表示表示：用来表示面向对象设计中的类和对象。：用来表示面向对象设计中的类和对象。：用来表示面向对象设计中的类和对象。：用来表示面向对象设计中的类和对象。连接连接连接连接：用来表示类和对象之间的关系和联系。：用来表示类和对象之间的关系和联系。：用来表示类和对象之间的关系和联系。：用来表示类和对象之间的关系和联系。类名类名类名类名数据成员数据成员数据成员数据成员成员函数成员函数成员函数成员函数cylindercylinderdouble
158、 radius, doube height;double radius, doube height;void setcylinder(doubler=5.0,double h=10.0);void setcylinder(doubler=5.0,double h=10.0);double getradius();double getheight();double getradius();double getheight();double volume();double surface_area();double volume();double surface_area();图图图图 Coad/
159、Yourdon Coad/Yourdon标记的标记的标记的标记的类的标记图类的标记图类的标记图类的标记图上部上部上部上部中部中部中部中部下部下部下部下部【3.10 3.10 面向对象标记面向对象标记面向对象标记面向对象标记】对象名对象名对象名对象名数据成员数据成员数据成员数据成员函数成员函数成员函数成员函数成员cylinder1cylinder1double radius, height;double radius, height;void setcylinder(double r,double h);void setcylinder(double r,double h);double get
160、radius();double getheight();double getradius();double getheight();double volume();double surface_area();double volume();double surface_area();上部上部上部上部中部中部中部中部下部下部下部下部连接符号分类连接符号分类连接符号分类连接符号分类带实心箭头的直线段带实心箭头的直线段带实心箭头的直线段带实心箭头的直线段表示消息联系表示消息联系表示消息联系表示消息联系带空心半圆的直线段带空心半圆的直线段带空心半圆的直线段带空心半圆的直线段表示继承关系表示继承关系表示
161、继承关系表示继承关系带空心三角形的直线段带空心三角形的直线段带空心三角形的直线段带空心三角形的直线段表示包含关系表示包含关系表示包含关系表示包含关系A AB BA A给给给给B B发送消息发送消息发送消息发送消息B B继承继承继承继承A AA A包括包括包括包括B BA AB BA AB B图图图图 Coad/Yourdon Coad/Yourdon标记的标记的标记的标记的连接符号连接符号连接符号连接符号图图图图 Coad/Yourdon Coad/Yourdon标记的标记的标记的标记的对象的标记图对象的标记图对象的标记图对象的标记图 类类类类C C包含了类包含了类包含了类包含了类A A的对象
162、的对象的对象的对象a1a1和类和类和类和类B B的对象的对象的对象的对象b1b1，它们是一种包含关系；，它们是一种包含关系；，它们是一种包含关系；，它们是一种包含关系；同时，类同时，类同时，类同时，类C C的构造函数使用了类的构造函数使用了类的构造函数使用了类的构造函数使用了类A A和类和类和类和类B B的构造函数，这是一个消息联系，的构造函数，这是一个消息联系，的构造函数，这是一个消息联系，的构造函数，这是一个消息联系，注注注注C CInt c;A a1; B b1;Int c;A a1; B b1;C(int x, int y);C(int x, int y);C(int x,int a,int)C(int x,int a,int)a1a1int a;int a;A(int x);A(int x);A();A();b1b1int b;int b;B(); B(int x);B(); B(int x);B()B()图图图图 Coad/Yourdon Coad/Yourdon标记的标记的标记的标记的类类类类A A、类、类、类、类B B与类与类与类与类C C的关系图的关系图的关系图的关系图结束结束
