《C++程序设计基础》-陆勤-电子教案-2941 第九章 对象与类

第九章 对象与类19.1

从结构化程序设计到面向对象程序设计2许多项目都接近或达到了结构化方法所不能处理的限度，为解决这一问题，就产生了面向对象的程序设计(Object-Oriented

Programming，简称

OOP）方法。面向过程：程序设计=数据结构+算法面向对象：程序设计=（数据结构+算法）3程序设计范型(Paradigm)是指设计程序的规范、模型和风格。不同的范型有不同的程序设计技术和方法学。过程程序设计范型：程序=过程+调用面向对象程序设计(OOP)范型（封装、继承、多态）程序=对象+消息4面向对象程序设计(OOP)范型的主要特点：程序基本元素是对象——由类创建。程序结构由类的定义和类的使用两部分组成。一切操作都通过向对象发送相应的消息来实现。类可自定义，但应尽量使用现成的类。类定义部分C++程序（声明和实现）类使用部分（主函数及子函数）9.2

面向对象程序结构及优点56面向对象程序设计的优点：控制程序的复杂性增强程序的模块性提高程序的重用性改善程序的可维护性能对现实世界的分类系统进行自然的描述很好地适应新的硬件环境7类的定义格式一般如下:class<类名>{

private:<数据成员><成员函数>protected:<数据成员><成员函数>public:<数据成员><成员函数>

};9.3

类与对象的定义8访问权限关键字特性：

private：私有部分。只能由本类的成员函数访问，不允许外界直接访问它，即私有成员对外是完全隐蔽的。

protected：保护部分。可以由本类的成员函数访问也可由本类的公有派生类的成员函数访问，但不允许外界直接访问它，即它是半隐蔽的。

public：公有部分。可由程序中的任何函数（包括类内和类外）访问。9说明:

三个部分并非一定要全有，但至少要有其中的一个部分。

若私有部分处于类体中第一部分时，关键字

private可以省略。

private、protected、public的次序和出现的次数可以是任意的。10例4

类date定义和对象today说明示例class

date

{public：void

setdate(int,int,int);//

设置月日年成员函数int

isleapyear(date);

//

判是否闰年成员函数int

howmanydays(date);//确定是该年第几天成员函数private：//月，数据成员//日，数据成员//年，数据成员int

month;int

day;int

year;}；date

today；11类的成员函数在类体内定义成员函数的格式如下:<返回类型><函数名>([<参数表>]){<函数体>}12在类体外定义成员函数的格式如下:<返回类型><类名>::<函数名>([<参数表>]){<函数体>}//域解析符”::”13

类的成员函数的定义可包含在类的定义中。类内的函数是内联函数。

只有那些非常简单的函数才在类声明中直接定义。

一般在类体中仅给出函数原型，而把函数体的定义放在类体外实现。

类的数据成员为该类的全体对象所共有，类的成员函数为该类的全体对象所共享。14例

学生类的定义class

Student{private:int

number;float

score;public:void

input(int

number1，float

score1);void

modify(float

score1);void

print();

};

//.h文件15void

Student::input(int

number1,float

score1){

number=number1;score=score1;

}void

Student::modify(float

score1){score=score1;

}void

Student::print(){cout<<

"

\nnumber:

"<<numter<<“score:”<<score;}//.cpp文件16仅含函数原型的类声明部分称为类的界面部分;类中成员函数的定义部分称为类的实现部分;类的界面部分一般存放在扩展名为h的文件中;类的实现部分则存放于扩展名为cpp文件中;

在.cpp文件的开头要用include将.h文件包含在其中。179.4

构造函数和析构函数专门用于对象自动生成和自动撤消的两个成员函数，称为构造函数和析构函数。1.构造函数特点：函数名与其所属类名相同，但无任何返回类型。例如，我们可给Student类定义构造函数如下:

Student::Student(int

number1，float

score1){

number=number1;score=score1;

}18在声明一个类变量时，系统自动调用构造函数对变量进行初始化，而生成对象。例如：

Studenta(10，90);

//创建了对象a构造函数可以重载。可以给Student类再定义一个构造函数：Student::Student(){

number=0;score=0;

}Studentb;//创建了对象b，其两个数据成员的值都是0。19利用构造函数直接创建对象的一般语法形式为:<类名>

<对象名>

[

(

<实参表>

)

]

;利用构造函数创建对象的第二种方法是：<类名>

*<指针>

=

new

<类名>[(<实参表>]

;例如：Student

*pa=new

Student(10，90);20例9定义complex的复数类，以执行有关复数和、差、积等。在类定义中包含构造函数，每当创建一个复数对象时，通过该构造函数对复数对象初始化，即令其实部与虚部均为0。#include<iostream>using

namespace

std;class

complex{public：complex（int=0,int=0）;void

setcomp（int,int）;void

addcomp（complex,complex）;void

subcomp（complex,complex）;void

mulcomp（complex,complex）;void

printcomp(

);private：

int

real;

int

imag;

};imag=z1.real*z2.imag+z2.real*z1.imag;}21complex::complex（int

re,int

im）{setcomp（re,im）;

}void

complex::setcomp（int

re,int

im）{real=re;

imag=im;

}void

complex::addcomp（complex

z1,complex

z2）{real=z1.real+z2.real;imag=z1.imag+z2.imag;

}void

complex::subcomp（complex

z1,complex

z2）{real=z1.real-z2.real;imag=z1.imag-z2.imag;

}void

complex::mulcomp（complex

z1,complex

z2）{real=z1.real*z2.real-z1.imag*z2.imag;void

complex::printcomp(

){cout<<”（”<<real<<”,”<<imag<<”）”;

}void

main(

){complex

z1,z2（5）,z;z.addcomp（z1,z2）;z1.printcomp(

);cout<<”+”;z2.printcomp(

);cout<<”=”;z.printcomp(

);

cout<<endl;z1.setcomp（8,9）;z2.setcomp（2,10）;z.subcomp（z1,z2）;

z1.printcomp(

);cout<<”-”;z2.printcomp(

);cout<<”=”;z.printcomp(

);cout<<endl;z.mulcomp（z1,z2）;

z1.printcomp(

);cout<<”*”;z2.printcomp(

);cout<<”=”;z.printcomp(

);cout<<endl;

}2223运行示例（0,0）+（5,0）=（5,0）（8,9）-（2,10）=（6,-1）（8,9）*（2,10）=（-74,98）24强调

在程序中无需也无法直接调用某类的构造函数。某类的构造函数在创建该类的对象时由系统自动调用。

不允许在类定义中说明类的数据成员时直接进行初始化。以下的类定义是不正确的：class

complex{……private：int

real=0;//错误!int

imag=0；//错误!};252.析构函数析构函数与所属类同名，定义时不能指定任何返回类型，但析构函数的函数名前要有一个”~”号，函数名后有一对圆括号，且其中无参数，函数体内一般仅由delete

p;形的删除语句组成，其中p为构造函数中指向由

new所开辟的内存空间的指针。26与类的构造函数相同的是，类的析构函数不带 有函数类型标识符，即不返回任何函数值。与类的构造函数不同的是，类的析构函数不接 受任何参数。一个类定义中只能定义一个析构函数，也就是 说，类的析构函数不能重载。但是，却允许定 义多个重载构造函数。27例10程序在类complex定义中包含一个不执行任何附加操作的析构函数定义，另外，所有类的公有成员函数包括构造函数、析构函数均在类定义内给出完整定义。#include<iostream>using

namespace

std;class

complex{public：complex（int

re=0,int

im=0）

{

setcomp（re,im）;

}void

setcomp（int

re,int

im）

{

real=re;imag=im;

}void

addcomp（complex

z1,complex

z2）{real=z1.real+z2.real;imag=z1.imag+z2.imag;

}void

subcomp（complex

z1,complex

z2）{real=z1.real-z2.real;imag=z1.imag-z2.imag;

}28void

mulcomp（complex

z1,complexz2）{real=z1.real*z2.real-z1.imag*z2.imag;imag=z1.real*z2.imag+z2.real*z1.imag;

}void

printcomp(

){

cout<<”（”<<real<<”,”<<imag<<”）”;

}～complex(

)

{

}private：int

real;int

imag;};29void

main(

){complex

z1,z2（5）,z3,z4,z5（4,15）,z6（11,5）,z;z.addcomp（z1,z2）;z1.printcomp(

);cout<<”+”;z2.printcomp(

);cout<<”=”;z.printcomp(

);cout<<endl;z3.setcomp（8,9）;z4.setcomp（2,10）;z.subcomp（z3,z4）;z3.printcomp(

);cout<<”-”;z4.printcomp(

);cout<<”=”;z.printcomp(

);cout<<endl;z.mulcomp（z5,z6）;z5.printcomp(

);cout<<”*”;z6.printcomp(

);cout<<”=”;z.printcomp(

);cout<<endl;

}30运行示例（0,0）+（5,0）=（5,0）（8,9）-（2,10）=（6,-1）（4,15）*（11,5）=（-31,185）31构造函数与析构函数的调用顺序类的构造函数在类的对象说明时即创建时自动调用。类的析构函数在类的对象撤消时即退出其作用域范围 时自动调用。调用构造函数与析构函数的顺序取决于创建和撤消类 的对象的顺序。类的析构函数的调用顺序与类的构造函数的调用顺序 正好相反。32例11

程序演示了类exam的诸对象在不同作用域中创建与撤消时其构造函数和析构函数的调用顺序。在类exam的定义中，还定义了重载构造函数。#include<iostream>using

namespace

std;class

exam{

public：exam(

){

num=1;cout<<”i”<<num<<”：constructor”<<endl;

}exam（int

i）

{

num=i;cout<<”i”<<num<<”：constructor”<<endl;

}～exam(

){

cout<<”i”<<num<<”：destructor”<<endl;

}private：

int

num;

};33void

func(

){

cout<<”Enter

func.”<<endl;exam

i4（4）;cout<<”Exit

func.”<<endl;}void

main(

){

cout<<”Enter

main.”<<endl;exam

i1,i2（2）,i3（3）;func(

);func(

);cout<<”Exit

main.”<<endl;}34运行示例

Enter

main.i1：constructori2：constructori3：constructorEnter

func.i4：constructorExit

func.i4：destructorEnter

func.i4：constructorExit

func.i4：destructorExitmain.i3：destructori2：destructori1：destructor35可见，对于在普通函数定义中的对象说明，由于它是局部对象，因此，当多次调用该函数时，每次对该函数的调用，该对象均将创建与撤消，故构造函数及析构函数将不止一次地被调用。36运算符重载是指将标准的、内部定义的运算符在类中 重新定义，以改变运算符的原有含义及功能，使其可 扩展至能执行对类的对象进行操作。在类中，将运算符定义成重载函数的形式，称为运算 符重载函数。重新定义的重载运算符可应用于实现抽象数据类型， 诸如复数类、集合类、栈类等等，从而扩展了C面向 对象程序设计的实现能力。9.6

用成员函数重载运算符37运算符重载时应遵循的一些规则：运算符重载机制可用来改变C语言所提供大多数标准的、内部预定义运算符的含义。一个被重载的运算符，就是一个用户自定义的运算符重载函数。运算符重载只能应用于类的对象。只能重载现有的内部预定义运算符。C++语言所提供内部预定义运算符中的大多数（而非全部）可用于运算符重载。运算符重载不能改变内部预定义运算符原有的优先级及结合性。必须遵循与特定运算符相联系的句法格式。38实现运算符重载的函数定义形式在C程序中，可使用如下三种不同的运算符重载函数定义形式进行运算符重载:用类的成员函数进行运算符重载。用顶层函数进行运算符重载。用类的友元函数进行运算符重载。39用成员函数重载运算符的一般格式为：<返回类型>operator<运算符>([<参数表>]）{<定义体>}其中，operator是函数的关键字。一元运算符则参数表为空，

二元运算符，则参数表中只有一个操作对象，这个操作对象代表右操作数，左操作数则由

this指针传给该函数。

this指针是构成运算符重载这一机制所必须的组成部分。40这种重载运算符函数的语义可表示为<对象>.operator<一元运算符>()或<对象1>.operator<二元运算符，<对象2>)前者可解释为给当前对象发送一个进行某一元运算的消息;

后者可解释为给当前对象1发送一个与对象2进行某二元运算的消息。

这两种语义表示形式也可作为重载后的相应运算符的使用形式(下面的友员函数重载运算符也一样)。但一般情况下人们还是沿用运算符通常的简洁表示形式。41例

成员函数重载运算符#include<iostream.h>class

Vector{int

X，y;public:Vector();//定义一个二维向量类Vector

(int

x1，int

y1);void

print();Vector

operator++(int);//在该类中重载一元运算符++Vector

operator+(Vector

v);//在该类中重载二元运算符十};42Vector::Vector(){x=0;y=0;}Vector::Vector(int

x1，int

y1){x=x1;y=y1;}void

Vector::print(){

cout<<"\n("<<x<<"，"<<y<<")";}Vector

Vector::operator++(int){

x++;y++;return

*this;

}Vector

Vectoc::operator十(Vector

v){

Vector

v0;v0.x=x+v.x;//这里的x相当于this->x，即左操作数的数据成员43v0·y=y+v.y;//这里的y相当于this-)y，即左操作数的数据成员

return

v0;}main(){

Vector

v1(10，10);v1.print();Vector

v11;v11=v1++;v1.print();v11.print();Vector

v2(20，20);//测试程序44(v1+v2).Print();Vector

v3;v3=v1+v2;v3.print();v3++·print();return

0

;}C++约定：对于前缀方式（++i）括号中为空;对于后缀方式（i--）括号中填写符号”int”。·程序的运行结果为·

(10，10)·

(11，11)·

(11，11)·

(31，31)·

(31，31)·

(32，32)459.7

使用类的友元函数进行运算符重载关于类的友元函数，有下列使用规则：类的友元函数不是类的成员，但它应在类中定义，在类的外部实现。在类中定义友元函数时，函数名前应前置关键字

friend，而在类的外部实现友元函数时，省略关键字

friend。类的友元函数可访问类的公有成员、私有成员和保护成员。this指针不能用于类的友元函数，它仅能用于类的成员函数。46友员函数重载运算符的一般格式为:friend

<返回类型>operator

<运算符>

([<参数表>]){<定义体>}其中，一元运算符参数表中只有一个操作对象;

二元运算符参数表中需要两个操作对象，它们分别代表左、右操作数。47这种重载运算符函数的语义可表示为:

operator<一元运算符>(<对象>)或operator<二元运算符>(<对象1，对象2>)前者表示：对当前对象进行某一元运算;后者表示：对当前对象1和对象2施行某二元运算。例

用友员函数重载运算符class

Vector{public:friend

Vector

operator十(Vector

v1，Vectorv2);};48Vector

operator+(Vector

v1,Vector

v2){Vector

v0;v0.x=v1.x+v2.x:Vo.y=v1.y+v2.y;return

v0;

}main(){

Vector

v1(10，10);

Vector

v2(20，20);

Vector

v3;v3=v1十v2;v3.print();reyurn

0;

}·程序运行结果为：·

(30，30)499.8类模板与模板类C++语言利用模板机制为类定义类模板（即设置通用 类型，可称为类