多态和虚函数、运算符重载
C--程序设计--第10章-多态性及虚函数
使用重载函数注意：
不要使用重载函数描述不相干的函数 在类中，构造函数和普通成员函数均可以
重载 避免与函数的默认参数产生二义性
二、运算符重载
运算符重载(operate overloading)就是 赋予已有的运算符多重含义。
运算符重载实质是函数重载，运算符重载 的选择与函数重载类似，会根据运算符的 操作数的类型、个数和顺序来进行运算符 函数的选择。
#include<iostream.h> str#iinngc:l:usdter<isntgr(icnhga.rh>*s) v{}ossccsssc{s{{ittohtttolsstlsssls*drruarrrueptrepttepsi1trii3tc{pn=rin=rrn=pmn.<nn.<lprgncngncign=agp<*ggp<auitepgtepnte'irssrssbv\hwy:hwyghwnsit1ssitsla0=(:=(:=(tnr=ttnrit'scssscs:sc)rt1"rrt3scesss~ivci;thpt1hpsih1(.T23(.t::tttsnohn}ra,r.a,tza()gh(()grrrrttiatlrsilrsrer";eass;eiiiirdre[)ne[1i;[Ttt1ttnnnniglnl;gnl.nlhl)rlggggnep*e(e}(gesgeiei;2e(((gtrsnsnstnp(nsns)ncsi(lipg)gthg)ig(;(htn)en;t;tr;t;nti)a)artnthhih}ths<<ri{((;+n++<p<snd))}1g1s1aere*ige;]]i]nonszl{{;&;z;ddgd)&eercseelrl;s=teo1)m;a;/18etu)om/)0ut..;)构sr<""/;pn<造);//;s;/复}lp函构e<制n<数造ge构tn函hd造;l数};重} 载
【C++面向对象的程序设计】6多态性
虚析构函数
析构函数的作用是对象撤销之后清理现场。 在派生类对象撤销时，一般先调用派生类的 析构函数。再调用基类的析构函数。
然而，当定义的是一个指向基类的指针变量， 使用new运算符建立临时对象时，如果基类 中有析构函数，则在使用delete析构时只会 调用基类的析构函数。
这就需要将基类中的析构函数声明为虚函数。
虚函数的声明与使用
声明虚函数的一般格式如下： virtual 函数原型；
⑴ 必须首先在基类中声明虚函数。 ⑵ 派生类中与基类虚函数原型完全相同的成员函 数，即使在说明时前面没有冠以关键字virtual也 自动成为虚函数。
声明虚函数
⑶ 只有非静态成员函数可以声明为虚函数。 ⑷ 不允许在派生类中定义与基类虚函数名字及参数 特征都相同，仅仅返回类型不同的成员函数。 编译时 出错。 ⑸ 系统把函数名相同但参数特征不同的函数视为不 同的函数。 ⑹ 通过声明虚函数来使用C++提供的多态性机制时， 派生类应该从它的基类公有派生。
构函数等内容。
本章内容
静态联编与动态联编 虚函数的声明与使用 纯虚函数和抽象类 虚析构函数
Hale Waihona Puke 静态联编与动态联编所谓联编(tinding)，就是使一个计算机程序的不同部 分彼此关联的过程。
静态联编在编译阶段完成，因为所有联编过程都在程 序开始运行之前完成，因此静态联编也叫先前联编或早期 联编。
另一种情况编译程序在编译时并不确切知道应把发送 到对象的消息和实现消息的哪段具体代码联编在一起，而 是在运行时才能把函数调用与函数体联系在一起，则称为 动态联编。
动态联编的实现
C ++语言中的动态联编是通过使用虚函数表 (Virtual Function Table)来实现的，虚函数表也称 为v-表。
第8章多态性模板
可以考虑重载整个运算符系列：
如果重载一个二元运算符（如运算符
+ ），那么类用户可以合理地假定一元
运算符 + 、一元运算符 ++ （包括前缀和 后缀）以及二元运算符 +=仍然可以像原 来一样使用。
13/69
8.2.2 运算符重载为成员函数
以双目运算符 + 为例，便捷地实现表达式 “X+y”，其中X为类A的对象； 如果要重载“+”为类 A 的成员函数，该函数 只有一个形参，形参的类型是y所属的类型。 经过重载之后，表达式X+y就相当于函数调用 “X.operator +(y)”; —— 基本原理
双目+运算符重载练习
int main() //是Chars的友元 { Chars A("hello "),B("world!"),C(""); C = A + B; cout << C.c << endl; C = A + "wld"; cout << C.c << endl; C += B; cout << C.c << endl; cout << "程序运行结束\n"; return 0; }
9/69
17:44
运算符重载的实现 运 算 符 重 载 的 实 现
17:44
运算符分为两类：单目、双目 运算符的重载形式有两种：重载为类的成员函 数和重载为类的友元函数。 运算符重载的语法形式如下：
<函数类型> operator <运算符>(<形参表>)
第9章 多态性
休息 26
前一页
例
运 算 符 重 载
将+、-（双目）重载为复数类的友元 函数。
两个操作数都是复数类的对象。
前一页
休息
27
#include<iostream.h> class complex //复数类声明 { public: //外部接口 complex(double r=0.0,double i=0.0) { real=r; imag=i; } //构造函数 friend complex operator + (complex c1,complex c2); //运算符+重载为友元函数 friend complex operator - (complex c1,complex c2); //运算符-重载为友元函数 void display(); //显示复数的值 private: //私有数据成员 double real; double imag; };
休息 25
前一页
运算符友元函数的设计
运 算 符 重 载
双目运算符 B重载后， 表达式oprd1 B oprd2 等同于operator B(oprd1,oprd2 ) 前置单目运算符 B重载后， 表达式 B oprd 等同于operator B(oprd ) 后置单目运算符 ++和--重载后， 表达式 oprd B 等同于operator B(oprd,0 )
休息 33
9.3.1 静态联编与动态联编
22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 class Circle :public Point { private: double radius; //半径 public: Circle(int X, int Y, double R):Point(X,Y) { radius=R; } double area() //求面积 { return PI*radius*radius; } }; void main() { Point P1(10,10); cout<<"P1.area()="<<P1.area()<<endl; Circle C1(10,10,20); cout<<"C1.area()="<<C1.area()<<endl; Point *Pp; Pp=&C1; cout<<"Pp->area()="<<Pp->area()<<endl; Point& Rp=C1; cout<<"Rp.area()="<<Rp.area()<<endl; }
简述面向对象中的多态
简述面向对象中的多态
面向对象中的多态是指一个对象可以以多种形态存在。
简单来说，多态就是同一个方法可以有不同的实现方式。
在面向对象的程序设计中，多态是一种非常重要的概念。
它能够提高代码的灵活性和可扩展性，使得代码更易于维护和扩展。
多态的实现方式主要有两种：静态多态和动态多态。
静态多态是通过函数的重载和运算符的重载来实现的。
函数的重载是指在同一个类中定义多个同名函数，但这些函数具有不同的参数列表。
运算符的重载是指对于某个运算符，可以定义多个不同的操作方式。
在编译时，编译器会根据调用时的参数类型来确定具体调用的函数或运算符。
动态多态是通过继承和虚函数来实现的。
继承是指子类可以继承父类的属性和方法，通过定义一个指向父类对象的指针或引用，可以调用子类对象中重写的方法。
虚函数是在父类中声明为虚函数的函数，子类可以对其进行重写。
在运行时，根据实际对象的类型来调用相应的方法。
多态具有很多优点。
首先，它可以提高代码的重用性，一个类的方法可以被多个类继承并重写，这样可以减少代码的重复编写。
其次，多态可以使代码更加灵活，可以根据需要动态地根据对象的类型来调用相应的方法。
再次，多态可以提高代
码的可扩展性，当需要添加新的功能时，只需要在子类中重写相应的方法即可，而不需要修改已有的代码。
总之，多态是面向对象编程中非常重要的概念，通过使用多态可以使代码更灵活、可扩展和易于维护。
它是面向对象编程中的重要特性之一，值得我们深入理解和应用。
C++_第12章_多态性_2010年_上半年
实现“一种接口，多种方法” 实现“一种接口，多种方法”的技术 调用同名的成员函数， 调用同名的成员函数，实现不同功能
多态性的两种形式
编译时多态性
编译器对源程序进行编译时就可以确定所调用的是 哪一个函数 编译时多态性通过重载来实现
函数重载 运算符重载
运行时多态性
在程序运行过程中根据具体情况来确定调用的是哪 一个函数
运行时多态
派生类对象替换基类对象
原则： 原则：
凡是基类对象出现的场合都可以用公有派生 类对象取代
形式
1. 2. 3.
派生类对象给基类对象赋值 派生类对象可以初始化基类对象的引用 可以令基类对象的指针指向派生类对象， 即 可以令基类对象的指针指向派生类对象 ， 将派生类对象的地址传递给基类指针
派生类对象替换基类对象
#include <iostream.h> //例12-1 class Pet //基类 {public: void Speak() { cout<<"How does a pet speak ?"<<endl; } }; class Cat : public Pet //派生类 {public: void Speak() { cout<<"miao!miao!"<<endl; } }; class Dog : public Pet //派生类 {public: void Speak() { cout<<"wang!wang!"<<endl; } }; int main() { Pet *p1, *p2, *p3,obj; //基类对象指针p1, 基类对象obj Dog dog1; Cat cat1; obj = dog1; //用Dog类对象给Pet类对象赋值 obj.Speak(); p1 = &cat1; //用Cat类对象地址给基类指针赋值 p1->Speak(); p1 = &dog1; //用Dog类对象地址给基类指针赋值 p1->Speak(); p2=new Cat; //动态生成Cat类对象 p2->Speak(); p3=new Dog; //动态生成Dog类对象 p3->Speak(); Pet &p4 = cat1; //以Cat类对象初始化Pet类引用 p4 .Speak(); return 0; }
C++实验5 运算符重载和多态性
friend int operator <(complex c1,complex c2); //运算符"<"重载友元函数
friend int operator<=(complex c1,complex c2); //运算符"<="重载友元函数
{ public://外部接口
complex(double r=0.0,double i=0.0)//构造函数
{real=r,imag=i;}
complex operator +(complex c2);//运算符"+"重载成员函数
complex operator - (complex c2);//运算符"-"重载成员函数
double real;
double imag;
};
int operator> (complex c1,complex c2)
{
double A=sqrt(c1.real*c1.real+c1.imag*c1.imag);
double B=sqrt(c2.real*c2.real+c2.imag*c2.imag);
分析：
计算这四种几何图的面积公式分别是：
三角形的边长为W，高为H时，则三角形的面积为W* H/2；矩形的边长为W，宽为H时，则其面积为W* H；正方形的边长为S，则正方形的面积为S*S；圆的半径为R，其面积为3.1415926 *R *R。
为设置几何图形的数据并求出几何图形的面积，需要定义一个包含两个虚函数的类：
航空工业出版社 C++程序设计教程第10章
10.4 运算符重载
运算符重载就是对已有的运算符赋予新的含义，使同一个 运算符作用于不同类型的数据时实现不同的操作。
10.4.1 运算符重载的定义
函数类型 operator运算符（参数列表） { 函数体 } 例如:
int operator+ (int a,int b){ … } //对运算符+重载，operator+是函数名
double Triangle::CalArea()const { //定义虚函数CalArea() double k,m,h,he; k=(y2-y1)/(x2-x1); m=-k*x1+y1; h=abs(k*xcoord-ycoord+m)/sqrt(k*k+1); he=sqrt((x2-x1)*(x2-x1)+(y2-y1)*(y2-y1)); cout<<"三角形面积:"<<endl; return h*he/2; } void main() { Point *shp[3]; //定义指向抽象类对象的指针变量 shp[0]=new Rect(0,0,100.44,243); //使指针指向派生类对象 shp[1]=new Circle(24,56,100.0); shp[2]=new Triangle(17.6,11,30.5,20,25,39); int i; for(i=0;i<3;i++) //依次调用派生类成员函数 cout<<“The area is ”<<shp[i]->CalArea()<<endl;}
第10章
多态性、虚函数 与运算符重载
本章内容提要
10.1 多态性的概念 10.2 虚函数 10.3 纯虚函数与抽象类 10.4 运算符重载 10.5 实现类型转换
青岛理工大学C 实验上机实验报告(3)
a=i;b=j;c=l;
y=j;
}
}
private:
virtual void disp(){
double a,b,c;
cout<<"y= "<<y<<endl;
};
}
double triangle::area(){
private:
int y;
double p=(a+b+c)/2;
};int main()
double r;
3
v=0):hour(i),minute(j),second(v)
};
{}
double circle::area()
void get();
{
void display();
return r*r*PI;
Time (Time &);
}
Time operator + ( Time);
int main()
"<<minute<<" : "<<second<<endl;
class Triangle
}
{
Time Time::operator + (Time time)
public:
{
Triangle(double i=0.0,double j=0.0,double
Time t;
v=0.0):a(i),b(j),c(v)
else {
t.hour=hour+24-time.hour; } return t; }Int main() {Time time1,time2,time3; time1.get(); time2.get(); time3=time1+time2; cout<<"时间的加法结果: \n"; time3.display(); time3=time1-time
C++ 8多态与虚函数
fun(i);
8.6.1 虚函数的定义
【例8.5_1】根据赋值兼容规则可以用基类的指针指向 派生类对象，如果由该指针撤销派生类对象，则必须将析构函 数说明为虚函数，实现多态性，自动调用派生类析构函数。 通常要求将类设计成通用的，无论其他程序员怎样调用都 必须保证不出错，所以必须把析构函数定义为虚函数。 下面把【例8.5】析构函数改造为虚函数 class Person{ //数据成员略 public: virtual ~Person(); //只需在此声明一次,派生类的析构函数全为虚函数 }; //其他成员函数略
8.6.1 虚函数的定义
成员函数设置为虚函数的要点：
1. 派生类中定义虚函数必须与基类中的虚函数同名外，还必须 同参数表，同返回类型。否则被认为是重载，而不是虚函数。 如基类中返回基类指针，派生类中返回派生类指针是允许的， 这是一个例外。 静态类型：在编译时可知的引用类型或指针类型 2. 只有类的成员函数才能说明为虚函数。这是因为虚函数仅适 class Base; Base *p; //指针p的静态类型为Base 用于有继承关系的类对象。 动态类型：指针或引用所绑定的对象类型，仅运行时可知 3. 静态成员函数，是所有同一类对象共有，不受限于某个对象， class Derived:public Base; 不能作为虚函数。 Derived d; Base *p=&d; //指针p的动态类型为Derived 4. 一个类对象的静态和动态构造是相同的，实现动态多态性时， 必须使用基类类型的指针变量或引用，使该指针指向该基类的 不同派生类的对象，并通过该指针指向虚函数，才能实现动态 的多态性。
编译时的多态性 在C++ 中有两 种多态 性 运行时的 多态性
面向对象程序设计填空题
1.对象有如下的特性：1 每个对象必须有一个名字以区别于其他对象。
2 有属性（或叫状态）来描述对象的某些特征。
3 有一组操作，每一操作决定对象的一种行为。
4 对象的整体性：把属性和操作放在一起，这里的操作要与属性相关，通过使用名字就可以使用整个对象。
2对象：静态特征——属性，一般用数据（结构）来体现。
动态行为——方法，基于数据的函数或过程。
3类是一组具有相同属性和行为特征的对象的抽象描述。
类和对象的关系：抽象和具体的关系，类是多个对象的归纳和总结（分类的结果），对象又是类的个体实物，一个对象就是类的一个实例。
4类和对象实际上就是C的数据类型和变量，在面向对象语言中，统称为类和对象。
类没有具体的值，对象才有，对象的这些具体的值称为对象的状态。
5类：数据成员——对应对象的属性，也叫做成员变量。
成员函数——对应对象的方法，是类功能的载体。
6类只在源程序的代码中出现，它是编译器生成对象的说明书，并不会在运行的程序中出现，即类只在编译时存在；对象作为类的实例是在运行的程序中出现，并占有内存空间，它是程序运行时存在的实体，是机器指令操作的内容。
7.对象的交互：现实世界的对象并非孤立的实体，它们间存在着联系，从而构成不同的系统。
面向对象程序设计中，对象的联系我们称为对象的交互。
对象交互的实现：在OOP中，对象交互的实现要用到一个重要的工具：事件消息。
8消息传递与调用实际上，对象的消息传递对应于程序设计中的过程（函数）调用。
比如：键盘对象的按键消息传给显示对象消息的发送和接收发送消息的对象为发送者或请求者，接收消息的目标对象为接收者或服务者（有处理者消息的能力）。
9.消息的内容组成包含有接收者的名字，请求的方法，一个或多个参数。
10.面向对象系统最突出的特征：封装性、继承性、多态性(三个特性)11抽象——从特定的实例抽取共同性质形成概念的过程。
抽象是对系统简化的描述或规范说明，它强调了系统中一部分细节和特性（用户关心的），而忽略了其他部分。
9 多态性
}
A graduate student
9.2 虚函数
注意：
在派生类中重新定义虚函数时，必须保证函数的返回值类型和参数与基
类中的声明完全一致，否则，编译器将认为重载虚函数。
如果在派生类中没有重新定义虚函数，则派生类的对象将使用基类的虚 函数代码； 静态函数不能声明为虚函数； 内联函数不能声明为虚函数；
抽象类的主要作用是将有关的派生类组织在一个继承层次结构中，由抽 象类为它们提供一个公共的根，相关的派生类就从这个根派生出来。
对于暂时无法实现的函数，可以声明为纯虚函数，留给派生类去实现。
抽象类不能用作参数类型、函数返回值类型或显式转换的类型，但可以 进而实现多态性。
说明指向抽象类的指针或引用，该指针或引用可以指向抽象类的派生类，
运行时多态性：动态联编
在程序运行过程中根据具体情况来确定调用的是哪一个函数。
• 虚函数
9.1 多态性概念
例如，编译时的多态性： class 兔子 参数不同： 老鹰a
{
public: …… void 逃生（老鹰a） {“兔子蹬鹰”；} void 逃生（狼 b） {“动如脱兔”；} ……
狼 b
已可以区分。
况下具有不同的解释。
在自然语言中，多态性即是“一词多义”。 换个角度说，多态性就是指相同的动词作用到不同类型的对象上。 例如： 驾驶摩托车 驾驶汽车 驾驶飞机 驾驶轮船
驾驶宇宙飞船
9.1 多态性概念
从专业角度说，多态性有两种表现形式： A. 不同的对象在收到相同的消息时，产生不同的动作；
只有在运行程序时才能确定将要调用的函数。 这种在运行阶段进行的联编称为动态联编。 优点：提供了更好的编程灵活性、问题抽象性和程序易维护性； 缺点：与静态联编相比，函数调用速度慢。
多态性与虚函数
第6章多态性与虚函数6.1 多态性概述6.2 重载与再定义6.3 运算符重载6.4 虚函数6.5 抽象类6.1 多态性概述6.1.1 多态的类型 6.1.2 多态的实现6.1.1 多态的类型多态性是指同一个消息被不同类型的对象接收时产生不同的行为，特点就是一个接口，多个实现。
Ｃ++中多态性按照类型可以分为强制多态、过载多态、包含多态和参数多态四种。
z强制多态是指通过语义操作，强制数据做本不属于该类型数据的操作。
编译器内部的数据的隐式转换，比如3.0+4操作时转换成3.0+4.0就属于此种类型z重载多态是指函数重载，同名的操作在不同的环境下有不同的行为。
前面学习过的普通函数重载和将要学习的类成员函数重载、运算符重载都属于此种类型。
z包含多态是指在同一类族中定义于不同类中的同名函数的多态行为。
我们本章将要学习的虚函数就属于此种类型。
z参数多态是指功能、结构实现相同但所作用于的数据类型不同，也就是数据类型参数化的多态。
第七章中的函数模板和类模板就属于此种多态。
6.1.2 多态的实现多态是指同一个消息被不同的对象接收产生不同的行为，因此，多态在实现的时候必须确定消息的操作对象。
我们根据消息和对象相结合的时间分为两种：z在程序编译连接阶段完成的，也就是说在编译的过程中确定了消息的操作对象，我们称为静态绑定。
z在程序运行阶段完成的，也就是说在程序运行的过程中才确定消息的操作对象，我们称为动态绑定。
6.2 重载与再定义6.2.1 函数的重载 6.2.2 函数的再定义6.2.1 函数的重载函数重载是指功能相似，函数名相同但所带参数不同的一组函数。
这里的“所带参数不同”既可能是参数的数据类型不同也可能是参数的个数不同。
z普通函数的重载。
int abs(int val){return val<0? –val: val;}float abs(float val){return val>0? –val: val;}6.2.1 函数的重载z类成员函数的重载。
第七章 函数的重载
7
实现函数重载
函数重载是通过在类中定义两个或更多的同名的函 数来实现函数重载。 数来实现函数重载。 在函数重载中， 在函数重载中，函数的每个定义必须在函数签名中 不同。 不同。
8
函数签名
函数的签名被下面的部分定义： 函数的签名被下面的部分定义：
参数的数量 参数的类型 参数的顺序 返回类型不是函数签名的一部分
public class DaysInYear { private int days; public DaysInYear(int days) 1.DaysInYear DIY = new DaysInYear(); { 2.DaysInYear DIY = new DaysInYear(5); this.days = days; 3.DaysInYear DIY = new DaysInYear("5"); } public DaysInYear(String dayOne) 4.DaysInYear DIY = new DaysInYear(‘5’); 5.DaysInYear DIY； { days =Convert.ToInt32(dayOne); } 1.错误 错误 public void setDay(int newDays) 2.调用int构造函数 调 构造函数 { 3.调用string构造函数 调 构造函数 days = newDays; 4.调用int构造函数 调 构造函数 } 5.没有对象生成，需要 没有对 或者让 没有 象生成，需要new或者让它指向一 或者 … 个DaysInYear对象 对 }
函数重载： 函数重载：这个方法允许为两个或更多函数使用同样 的名字。 的名字。函数的每个重新定义必须使用不同的参数类 参数顺序或多个参数。 型、参数顺序或多个参数。 操作符重载： 操作符重载：这个方法允许用户定义的类型例如结构 和类，为使它们的对象易于操作而使用重载操作符。 和类，为使它们的对象易于操作而使用重载操作符。
《C++面向对象程序设计》 谭浩强 第六章
C++
先声明基类point类，并调试之； 再声明派生类circle类，调试之； 最后声明cylinder类，调试之。
6- 5
① 先声明基类point
#include <iostream.h> class point //声明类point {public: point (float x=0, float y=0 ); //有默认值的构造函数 void setPoint (float, float); //设置点坐标 float getX ( ) const { return x; } // 读x 值 float getY ( ) const { return y; } // 读y 值 friend ostream & operator << ( ostream &, const point &); protected: float x,y; }; // 下面定义 point类的成员函数 point :: point (float a, float b) // point的构造函数 { x = a; y = b; } void point :: setPoint (float a, float b) { x =a; y = b; } ostream &operator << (ostream &output, const point &p) { // 重载运算符<< output<<“[x=“<<p.x<<“, y=“<<p.y<<“]”<<endl; return output; }
6Hale Waihona Puke 7③ 最后声明cylinder类
C++程序设计基础第6章 虚函数与多态性
6.2.1 虚函数的定义
2. 虚函数的定义 • 虚函数的定义是在基类中进行的 。 • 虚函数的定义语法格式如下：
virtual<函数类型><函数名>(形参表) {
函数体 }
12
6.2.1 虚函数的定义
3. 定义虚函数时，要注意遵循以下规则： 1）只有成员函数才能声明为虚函数，因为虚
函数仅适用于有继承关系的类对象，所以 普通函数不能声明为虚函数。 2）虚函数的声明只能出现在类声明中的函数 原型声明中，而不能出现在成员的函数体 实现上。 3）类的静态成员函数不可以定义为虚函数， 因为静态成员函数不受限于某个对象。
}
7
void main()
{
MaxClass mc(34,67,143,89);
cout<<"计算前两个数中的最大数为:“
<<mc.max(34,67)<<endl;
cout<<"计算前三个数中的最大数为:“
<<mc.max(34,67,143)<<endl;
cout<<"计算四个数中的最大数为:“
运行结果： 张晓强,园林工人 李文卓,生命科学教师
23
6.2.3 虚函数的重载
• 2. 多继承中的虚函数
【例6.8】多继承中使用虚函数例题。
#include <iostream.h>
class base1
//定义基类base1
{
public: virtual void display()
//函数定义为虚函数
运行结果：
(1) : 动物(食草/食肉). (2) : 食草动物 : 羚羊 (3) : 食草动物 : 羚羊 (4) : 食肉动物 : 老虎 (5) : 食肉动物 : 老虎 (6) : 食草动物 : 羚羊 (7) : 食肉动物 : 老虎
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
(3)单击标准工作栏的Save按钮，将文件保存到指定地点，并命名。
(4)编译运行。
3、输入并运行程序Ex_Complex的具体步骤如下。
(1) 选择“文件” “关闭工作区间”，关闭原来的项目。
(2) 单击标准工具栏上的“New Text File”按钮，在新打开的文档窗口中输入下列程序代码：
#include<iostream.h>
class CComplex
{
public:
CComplex(double r=0,double i=0)
{realPart=r;imagePart=i;}
void print()
{cout<<"该复数实部="<<realPart<<",虚部="<<imagePart<<endl;}
CComplex operator*(CComplex &b);//成员函数重载运算符*
friend CComplex operator/(CComplex &a,CComplex &b);友元函数重载运算符private:
五、分析与体会：
1、象程序设计多态性是面向对象程序设计的重要特征之一，他与封装性和继承
性构成了面向对的三大特征。
所谓多态性，是指不同类型的对象接受相同的消息是产生不同的行为。
这里的消息主要是指对类的成员函数的调用，而不同的行为是指成员函数的不同实现。
如：函数重载就是多态的典型例子。
2、此程序中定义了一个抽象类CShape，包含纯虚函数Area和SetData，Area用于计算各个形状的面积，SetData用于重设各个形状的大小。
程序代码中虚函数Area和SetData是通过在基类函数的前面加上virtual关键字来实现的。
程序中ppShape是定义的基类CShape的指针，通过语句ppShape[0]=newTriangle(triWidth,triHeight);ppShape[1]=new(rcWidth,rcHeight); ppShape[2]=new CCircle(r);是将ppShape[0]、ppShape[1]和ppShape[2]分别获得对派生类CTriangle、CRect和CCircle的成员函数的调用，因而语句ppShape[n]->SetData(f1,f2);根据n值的不同调用不同的形状类的area函数，例。