C++第9次作业

实验九: 多态性（一）

1、定义计数器Counter类，对其重载运算符+ 。

实验代码：

#include

class counter

{

private:

int n;

public:

counter( ) { n=0;}

counter(int i) {n=i;}

counter operator+(counter c)

{

counter temp;

temp.n=n+c.n;

return temp;

}

void disp( )

{

cout<<"n="<

}

};

void main()

{

counter c1(15),c2(10),c3;

c3=c1+c2;

c1.disp();

c2.disp();

c3.disp();

}

实验结果：

2、定义一个基类BaseClass，从它派生出类DerivedClass，BaseClass有成员函数fn1()、fn2()，

DerivedClass也有成员函数fn1()、fn2()，在主程序中定义一个DerivedClass的对象，分别用DerivedClass的对象以及BaseClass和DerivedClass的指针来调用fn1()、fn2()，观察运行结果。

实验代码：

#include

class BaseClass

{

public:

void fn1();

void fn2();

};

void BaseClass::fn1()

{

cout << "调用基类的函数fn1()" << endl;

}

void BaseClass::fn2()

{

cout << "调用基类的函数fn2()" << endl;

}

class DerivedClass : public BaseClass

{

public:

void fn1();

void fn2();

};

void DerivedClass::fn1()

{ cout << "调用派生类的函数fn1()" << endl; } void DerivedClass::fn2()

{ cout << "调用派生类的函数fn2()" << endl; } void main()

{

DerivedClass aDerivedClass;

DerivedClass *pDerivedClass = &aDerivedClass;

BaseClass *pBaseClass = &aDerivedClass;

aDerivedClass.fn1();

aDerivedClass.fn2();

pBaseClass->fn1();

pBaseClass->fn2();

pDerivedClass->fn1();

pDerivedClass->fn2();

}

实验结果：

3、实现重载函数Double(x)，返回值为输入参数的两倍；参数分别为整型、长整型、浮点

型、双精度型，返回值类型与参数一样。

实验代码：

#include

using namespace std;

int Double(int a){return 2.0*a;}

long int Double(long int a){return 2*a;}

float Double(float a){return 2.0*a;}

double Double(double a){return 2.00000*a;}

void main(){

int m;

cout<<"输入一个整型数：";

cin>>m;

cout<<"它的两倍是"<

long int p;

cout<<"输入一个长整型数：";

cin>>p;

cout<<"它的两倍是"<

float r;

cout<<"输入一个浮点型数：";

cin>>r;

cout<<"它的两倍是"<

double n;

cout<<"输入一个双精度数：";

cin>>n;

cout<<"它的两倍是"<

}

实验结果：

4、定义一个复数类，重载“+”；“-”；“*”，“/”运算符实现复数的四则运算。

实验代码：

#include

class complex

{

private:

double real;

double imag;

public:

complex()

{

real=imag=0;

}

complex(double rpart,double ipart)

{

real=rpart;

imag=ipart;

}

complex operator+(const complex &com)

{

complex temp;

temp.real=real+com.real;

temp.imag=imag+com.imag;

return temp;

}

complex operator-(const complex &com)

{

complex temp;

temp.real=real-com.real;

temp.imag=imag-com.imag;

return temp;

}