实验11(操作符重载,多态性)
操作符重载实验报告
Console.WriteLine("请输入第二个分数的分母:");
int d1 = Convert.ToInt32(Console.ReadLine());
Praction newPraction1 = new Praction(m1, d1);
实验报告
姓名:学号:日期:
实验名称:操作符重载编程练习成绩:
一、实验目的及要求
实验目的
1.了解操作符重载的意义,掌握操作符重载的一般方法。
2.理解操作符对的重载实现,编写相应的程序。
实验要求
1.写出程序,并调试程序,要给出测试数据和实验结果。
2.整理上机步骤,总结经验和体会。
3.完成实验日志和上交程序。
addPraction.Display();
Console.WriteLine("------------------------------------------------------------------------- ---");
}
}
}
四、实验调试过程及运行结果
五、实验总结:
二、实验环境
Windows 7操作系统,Visual 2010
三、实验源程序及关键代码解释
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace操作符重载
}
}
class Program
{
static void Main(string[] args)
运算符重载实验报告
运算符重载实验报告运算符重载实验报告引言:运算符重载是C++语言中的一项重要特性,它允许用户自定义运算符的行为。
通过运算符重载,可以使得程序更加直观、简洁,并提高代码的可读性和可维护性。
本实验旨在探索运算符重载的用法和效果。
一、实验目的本实验旨在通过实际操作,深入了解运算符重载的机制和使用方法,以及运算符重载对程序设计的影响。
二、实验环境本实验使用C++编程语言,并在Visual Studio开发环境下进行实验。
三、实验过程1. 了解运算符重载的基本概念运算符重载是指通过定义函数,改变运算符的行为。
在C++中,可以通过重载运算符函数来实现运算符的重载。
运算符重载函数的命名规则为"operator 运算符",例如"operator+"表示重载加法运算符。
2. 实现运算符重载的实验示例为了更好地理解运算符重载的使用方法,我们以矩阵的加法为例进行实验。
首先,定义一个Matrix类,并重载"+"运算符。
```cppclass Matrix {private:int** data;int rows;int cols;public:Matrix(int rows, int cols) {this->rows = rows;this->cols = cols;data = new int*[rows];for (int i = 0; i < rows; ++i) {data[i] = new int[cols];}}Matrix operator+(const Matrix& other) {Matrix result(rows, cols);for (int i = 0; i < rows; ++i) {for (int j = 0; j < cols; ++j) {result.data[i][j] = data[i][j] + other.data[i][j]; }}return result;}};```在上述代码中,我们定义了一个Matrix类,其中包含矩阵的数据成员data、行数rows和列数cols。
实验报告多态性
一、实验目的1. 理解多态性的概念及其在面向对象编程中的重要性。
2. 掌握多态性的实现方式,包括方法重载和方法覆盖。
3. 学习如何利用多态性提高代码的可读性和可维护性。
4. 通过实例分析,加深对多态性在实际编程中的应用理解。
二、实验背景多态性是面向对象编程中的一个核心概念,它允许同一个接口(或方法)根据不同的数据类型执行不同的操作。
在Java、C++等面向对象编程语言中,多态性主要通过方法重载和方法覆盖来实现。
三、实验内容1. 方法重载方法重载是指在同一个类中,允许存在多个同名方法,但参数列表不同。
编译器通过参数列表的匹配来确定调用哪个方法。
(1)实验步骤1)创建一个名为“Animal”的类,包含一个方法名为“makeSound”。
2)在“Animal”类中,添加三个重载的“makeSound”方法,分别接受不同类型的参数(如int、String、double)。
3)创建一个名为“Dog”的类,继承自“Animal”类,并重写“makeSound”方法,使其输出“Woof! Woof!”。
4)创建一个名为“Cat”的类,继承自“Animal”类,并重写“makeSound”方法,使其输出“Meow! Meow!”。
(2)实验结果当创建“Dog”和“Cat”对象时,调用“makeSound”方法会根据对象类型输出相应的声音。
2. 方法覆盖方法覆盖是指在子类中重写父类的方法,使子类的方法具有与父类方法相同的签名,但具有不同的实现。
(1)实验步骤1)创建一个名为“Vehicle”的类,包含一个方法名为“move”,该方法无参数。
2)创建一个名为“Car”的类,继承自“Vehicle”类,并重写“move”方法,使其输出“Car is moving”。
3)创建一个名为“Bike”的类,继承自“Vehicle”类,并重写“move”方法,使其输出“Bike is moving”。
(2)实验结果当创建“Car”和“Bike”对象时,调用“move”方法会根据对象类型输出相应的移动信息。
《C 程序设计实例与操作》课件第10章 多态性、虚函数与运算符重载
t.imag=imag+c.imag;
return t;
} 则a+b为隐式调用,它等价于a.operator+(b),这是显式调用。
2.单目运算符重载作为类的成员函数
单目运算符重载作为类的成员函数时,操作数为访问该重 载运算符的对象本身的数据,也由this指针指出,因此,单目 运算符重载函数没有参数。
2.赋值运算符的重载
通常情况下,系统会自动生成一个默认的赋值运算符函数, 提供同类对象之间进行赋值的功能。但在某些特殊情况下,必 须要定义一个赋值运算符重载函数。
10.5 实现类型转换
类型转换函数用来将类类型转换为标准数据类型。
operator 类型名() { 转换语句 } 类型转换函数只能作为成员函数,不能作为友元函数,它又 称为类型转换运算符重载函数。
{}
virtual~ Point()
//定义虚析构函数
{}
virtual double CalArea() const=0;
//定义纯虚函数
};
class Rect:public Point {
//定义派生类Rect
protected:
double xcoord1,ycoord1;
public:
双目运算符重载为友元函数时,由于没有this指针,所以 操作数要通过友元函数的参数指出。
例如:
operator+(a,b); a+b;
//显式调用 //隐式调用
4.单目运算符重载作为类的友元函数
与双目运算符重载作为友元函数类似,单目运算符重载作 为友元函数时,操作数要通过友元函数的参数指出。
例如:
operator++(a); ++a;
“计算机程序设计”课程教学大纲
计算机程序设计”课程教学大纲英文名称:C++Programming课程编号:COMP1001学时:64学分:3适用对象:一、二年级学生先修课程:大学计算机基础一、课程性质、目的和任务性质:“计算机程序设计”是面向非计算机类各专业的必修计算机类基础课程,是计算机教育的基础和重点。
目的:使学生掌握一门高级程序设计语言,掌握结构化程序设计和面向对象程序设计的基本方法,同时了解初步的数据结构与算法等方面的知识,具有把各个领域的基本计算和数据处理问题变成计算机应用程序的能力,为后续课程的学习创造条件。
任务:介绍计算机程序设计语言的基本知识和程序设计的方法与技术,同时包括程序设计方法学、数据结构与算法基础等方面的内容。
二、教学基本要求1.C++语言基础知识掌握变量与常量的定义与使用方法;掌握基本数据类型和表达式的使用方法,掌握C++的基本语句。
理解结构化和面向对象程序设计的基本思想和有关概念,掌握C++程序的基本框架和上机调试计算机程序的过程。
2.数组、指针与引用掌握数组的定义、初始化和访问方法;掌握字符串使用方法;理解指针和引用的概念,掌握指针使用方法,理解指针与数组的关系,了解动态内存管理方法。
3.函数掌握函数的定义与函数调用方法,理解变量的生命周期、作用域和存储类别(自动、静态、寄存器、外部),掌握C++库函数的使用方法。
4.类与对象的基础知识理解类与对象的基本概念,掌握类及其成员的声明、定义、访问方法,对象的创建与使用方法;掌握构造函数与析构函数的定义与使用;掌握静态数据成员与静态成员函数的定义与使用。
5.类的复用掌握类的组合语法;掌握派生类的定义和访问权限,类的数据成员与成员函数的继承;理解多态性概念及虚函数机制的要点;了解运算符重载。
6.输入/输出流理解C++流的概念,掌握数据的格式输入输出,掌握文件的I/O操作。
7.综合程序设计能力掌握利用所学到的面向对象的程序设计方法,编制含有多个类的程序;掌握根据实际问题和给定的算法,设计类结构并编码实现,解决小型问题。
“计算机程序设计”课程教学大纲
“计算机程序设计”教学大纲一、课程性质、目的和任务性质:“计算机程序设计”是面向非计算机类各专业的必修计算机类基础课程,是计算机教育的基础和重点。
目的:使学生掌握一门高级程序设计语言,掌握结构化程序设计和面向对象程序设计的基本方法,同时了解初步的数据结构与算法等方面的知识,具有把各个领域的基本计算和数据处理问题变成计算机应用程序的能力,为后续课程的学习创造条件。
任务:介绍计算机程序设计语言的基本知识和程序设计的方法与技术,同时包括程序设计方法学、数据结构与算法基础等方面的内容。
二、教学基本要求1.C++语言基础知识掌握变量与常量的定义与使用方法;掌握基本数据类型和表达式的使用方法,掌握C++的基本语句。
理解结构化和面向对象程序设计的基本思想和有关概念,掌握C++程序的基本框架和上机调试计算机程序的过程。
2.数组、指针与引用掌握数组的定义、初始化和访问方法;掌握字符串使用方法;理解指针和引用的概念,掌握指针使用方法,理解指针与数组的关系,了解动态内存管理方法。
3.函数掌握函数的定义与函数调用方法,理解变量的生命周期、作用域和存储类别(自动、静态、寄存器、外部),掌握C++库函数的使用方法。
4.类与对象的基础知识理解类与对象的基本概念,掌握类及其成员的声明、定义、访问方法,对象的创建与使用方法;掌握构造函数与析构函数的定义与使用;掌握静态数据成员与静态成员函数的定义与使用。
5.类的复用掌握类的组合语法;掌握派生类的定义和访问权限,类的数据成员与成员函数的继承;理解多态性概念及虚函数机制的要点;了解运算符重载。
6.输入/输出流理解C++流的概念,掌握数据的格式输入输出,掌握文件的I/O操作。
7.综合程序设计能力掌握利用所学到的面向对象的程序设计方法,编制含有多个类的程序;掌握根据实际问题和给定的算法,设计类结构并编码实现,解决小型问题。
8.程序调试掌握C++程序调试的基本方法;理解程序错误的种类和产生的原因,掌握排除语法错误的基本技能;掌握程序调试的基本技能(如设置断点、单步执行、查看中间运行结果等)。
运算符重载实验报告
一、实验目的1. 理解运算符重载的概念和原理。
2. 掌握C++中运算符重载的方法和规则。
3. 通过实例,实现自定义类型对运算符的重载。
4. 分析运算符重载在实际编程中的应用和优势。
二、实验环境1. 编程语言:C++2. 开发环境:Visual Studio 20193. 操作系统:Windows 10三、实验内容1. 运算符重载的概念和原理2. 运算符重载的方法和规则3. 自定义类型运算符重载实例4. 运算符重载的实际应用四、实验步骤1. 概念和原理运算符重载是指为已有的运算符赋予新的功能,使其能够应用于自定义类型的数据。
在C++中,运算符重载可以通过成员函数或友元函数实现。
2. 方法和规则- 成员函数重载:在自定义类型中定义一个成员函数,该函数的名称与要重载的运算符相同。
- 友元函数重载:在自定义类型外部定义一个友元函数,该函数的名称与要重载的运算符相同,并在函数声明中添加类名和作用域解析运算符。
运算符重载规则:- 运算符重载的函数必须返回与操作数相同的类型。
- 运算符重载的函数不能改变原有运算符的操作数个数。
- 运算符重载的函数不能改变原有运算符的优先级。
- 运算符重载的函数不能改变原有运算符的结合性。
3. 自定义类型运算符重载实例假设我们有一个自定义类型`Point`,表示二维平面上的一个点,其坐标为`(x, y)`。
```cppclass Point {public:int x, y;Point(int x, int y) : x(x), y(y) {}// 成员函数重载加法运算符Point operator+(const Point& p) const {return Point(x + p.x, y + p.y);}// 友元函数重载加法运算符friend Point operator-(const Point& p1, const Point& p2);};// 实现友元函数重载减法运算符Point operator-(const Point& p1, const Point& p2) {return Point(p1.x - p2.x, p1.y - p2.y);}```4. 运算符重载的实际应用运算符重载在实际编程中具有以下优势:- 提高代码可读性:使用自定义类型时,可以像操作基本数据类型一样使用运算符,提高代码的可读性。
习题10-运算符重载与多态性
习题10 运算符重载与多态性一、单项选择题1、下列运算符中,()运算符在C++中不能重载。
A、? :B、[ ]C、newD、&&2、下列运算符不能用友元函数重载的是()。
A、+B、=C、*D、<<3、在一个类中可以对一个操作符进行()重载。
A、1种B、2种以下C、3种以下D、多种4、友元运算符obj1>obj2被C++编译器解释为()。
A、operator > (obj1, obj2)B、> (obj1, obj2)C、obj2.operator > (obj1)D、obj1.operator > (obj2)5、下列关于C++运算符函数的返回类型的描述中,错误的是()。
A、可以是类类型B、可以是int类型C、可以是void类型D、可以是float类型6、下列关于运算符重载的描述中,正确的是()。
A、运算符重载可以改变运算符的操作数的个数B、运算符重载可以改变优先级C、运算符重载可以改变结合性D、运算符重载不可以改变语法结构7、下列关于动态联编的描述中,错误的是()。
A、动态联编是以虚函数为基础的B、动态联编是在运行时确定所调用的函数代码的C、动态联编调用函数操作是指向对象的指针或对象引用D、动态联编是在编译时确定操作函数的8、关于虚函数的描述中,正确的是()。
A、虚函数是一个静态成员函数B、虚函数是一个非成员函数C、虚函数既可以在函数说明时定义,也可以在函数实现时定义D、派生类的虚函数与基类中对应的虚函数具有相同的参数个数和类型9、对虚函数的调用()。
A、一定使用动态联编B、必须使用动态联编C、一定使用静态联编D、不一定使用动态联编10、编译时的多态性可以通过使用()获得。
A、虚函数和指针B、重载函数和析构函数C、虚函数和对象D、虚函数和引用11、实现运行时的多态性要使用()。
A、重载函数B、构造函数C、析构函数D、虚函数12、要实现动态联编,必须通过()调用虚函数。
运算符重载—C++课程实验报告
using namespace std; class AB
{
public:
AB(int xx, int yy); void ShowAB(); AB& operator ++(); AB operator ++(int);
AB& operator --();
AB operator --(int);
通过这次实验我基本掌握了通过运算符重载实现多态性的方法学会了运算符重载的成员函数法和友元函数法基本能够区分单目运算符的前置与后置
C++
学生姓
名
xxx
班级
学号
xxxxxxxxx
实验项
目
实验四运算符重载
指导教师
杜之波
实验目
的和要
求
一、实验目的
(1)掌握通过运算符重载实现多态性的方法;
(2)学会运算符重载的成员函数法和友元函数法;
运算后,
A的值为:"
什+AA).ShowAB();
coutvv"
B
的值为:";
(++BB).ShowAB();
cout<v"B=A--运算后,A的值为:";
(--AA).ShowAB();
coutvv"B的值为:";
(BB--).ShowAB();
cout<<"B=--A运算后,A的值为:";
(--AA).ShowAB();
{
AB AA(0,0);
AB BB(0,0);
cout<v"A的值为:";
运算符重载和多态性
compare(c2,c3);
return 0;
}
测试结果:
3.利用虚函数实现的多态性来求四种几何图形的面积之和。这四种几何图形是:三角形、矩形、正方形和圆。几何图形的类型可以通过构造函数或通过成员函数来设置。
⑴分析
计算这四种几何图的面积公式分别是:
三角形的边长为W,高为H时,则三角形的面积为W* H/2;矩形的边长为W,宽为H时,则其面积为W* H;正方形的边长为S,则正方形的面积为S*S;圆的半径为R,其面积为3.1415926 *R *R。
else
return false;
}
bool operator<=(complex c1,complex c2)
{
if(sqrt(c1.real*c1.real+c1.imag*c1.imag)<sqrt(c2.real*c2.real+c2.imag*c2.imag)||sqrt(c1.real*c1.real+c1.imag*c1.imag)==sqrt(c2.real*c2.real+c2.imag*c2.imag))
return c;
}
void Complex::display()
{cout<<"("<<real<<","<<imag<<"i)"<<endl;}
int main()
{
Complex c1(4,7),c2(2,1),c3;
cout<<"c1=";
c1.display();
cout<<"c2=";
运算符重载-- 实验报告
南昌航空大学实验报告2011年12月1号课程名称:面向对象程序设计B 实验名称:运算符重载班级:姓名:同组人:无指导教师评定: 签名:一、实验目的理解运算符重载(非成员形式和成员形式)、学习重载几类运算符(++,=,!=,+,-,==等)。
二、实验内容应用VC++6.0的构建一个复数类Complex,试对下列几个运算符进行重载:++,=,!=,+,-,==,其中要求要有成员重载形式和友元重载形式,而且,++运算符要求实现先加和后加两种形式。
三、概要设计函数原型:class complex{private:double real;double image;public:complex(double r=0,double i=0);complex &operator+(complex &c);complex operator-(complex &c);complex operator*(complex &c);friend complex operator/(complex &c1,complex &c2);friend bool operator==(complex &c1,complex &c2);friend bool operator!=(complex &c1,complex &c2);complex operator++();complex operator++(int);void show();};四、详细设计重载运算符 + 的函数:complex &complex::operator+(complex &c){complex temp;temp.real=real+c.real;temp.image=image+c.image;return temp;}重载运算符 - 的函数:complex complex::operator-(complex &c){complex temp;temp.real=real-c.real;temp.image=image-c.image;return temp;}重载运算符 * 的函数:complex complex::operator*(complex &c){complex temp;temp.real=real*c.real;temp.image=image*c.image;return temp;}重载运算符 / 的函数:complex operator/(complex &c1,complex &c2){complex temp;double t;t=1/(c2.real*c2.real+c1.image*c1.image);temp.real=(c1.real*c2.real+c1.image*c2.image)*t;temp.image=(c2.real*c1.image-c1.real*c2.image)*t;return temp;}重载运算符 == 的函数:bool operator==(complex &c1,complex &c2){if(c1.real==c2.real&&c1.image==c2.image)return true;elsereturn false;重载运算符 != 的函数:bool operator!=(complex &c1,complex &c2){if(c1.real!=c2.real||c1.image!=c2.image) return true;elsereturn false;}重载运算符 ++ 的函数:complex complex::operator++(){++real;++image;return *this;}complex complex::operator++(int){real++;image++;return *this;}五、程序调试经调试无误后,运行的结果为:六、实验总结通过这次的试验,我明显的感觉到自己对这方面的知识掌握的还不够熟练,不能顺利地、流畅地运用这方面的知识,因为我没有在规定的时间内完成程序的设计,课后还是要多复习。
多态性实验报告
一、实验目的通过本次实验,加深对多态性的理解,掌握多态性的基本概念、实现方式以及在Java语言中的应用,提高面向对象编程的能力。
二、实验环境1. 操作系统:Windows 102. 开发工具:Eclipse3. 编程语言:Java三、实验内容1. 多态性基本概念多态性是指同一个操作作用于不同的对象,可以有不同的解释,产生不同的执行结果。
在Java中,多态性主要表现在两个方面:方法重载和方法重写。
2. 方法重载方法重载是指在一个类中,允许存在多个名称相同、参数列表不同的方法。
编译器通过参数列表来区分这些方法,实现多态性。
(1)实验步骤1) 创建一个名为“Shape”的类,包含一个方法“draw()”,该方法不接受任何参数。
2) 在“Shape”类中添加三个方法:draw(String color),draw(String color, int size),draw(int x, int y)。
3) 创建一个名为“Circle”的类,继承自“Shape”类,并添加一个名为“draw”的方法,该方法接受一个int类型的参数radius。
4) 创建一个名为“Rectangle”的类,继承自“Shape”类,并添加一个名为“draw”的方法,该方法接受两个int类型的参数width和height。
5) 在主类中创建“Circle”和“Rectangle”对象,并调用它们的draw()方法。
(2)实验结果当执行程序时,根据传入的参数不同,调用不同的draw()方法。
3. 方法重写方法重写是指子类在继承父类的基础上,对父类的方法进行修改,实现多态性。
(1)实验步骤1) 创建一个名为“Animal”的类,包含一个名为“makeSound”的方法。
2) 创建一个名为“Dog”的类,继承自“Animal”类,并重写“makeSound”方法,使其输出“汪汪”。
3) 创建一个名为“Cat”的类,继承自“Animal”类,并重写“makeSound”方法,使其输出“喵喵”。
多态性实验报告
多态性实验报告多态性实验报告引言:多态性是面向对象编程中的一个重要概念,它允许对象在不同的上下文中表现出不同的行为。
本实验旨在通过一系列的实验来探究多态性的概念和应用,以及它对程序设计的影响。
实验一:多态性的概念在本实验的第一部分,我们首先对多态性的概念进行了深入的研究。
多态性是指同一个方法在不同的对象上表现出不同的行为。
例如,在一个动物类中,不同的子类(如狗、猫、鸟)都可以实现一个叫声的方法,但是每个子类的叫声是不同的。
这种灵活性使得我们可以编写更加通用和可扩展的代码。
实验二:多态性的应用在第二个实验中,我们通过一个图形绘制的例子来展示多态性的应用。
我们创建了一个抽象的图形类,并派生出不同的子类,如圆形、矩形和三角形。
每个子类都实现了一个绘制方法,但是绘制的方式和结果是不同的。
通过将这些不同的子类对象存储在一个通用的图形数组中,我们可以轻松地遍历并绘制每个图形,而无需关心具体的子类类型。
实验三:多态性的优势和局限性在第三个实验中,我们深入研究了多态性的优势和局限性。
多态性使得代码更加灵活和可扩展,可以减少代码的重复性。
然而,过度使用多态性可能会导致代码的复杂性增加,降低程序的性能。
因此,在设计和实现中需要权衡多态性的使用。
实验四:多态性在实际项目中的应用在最后一个实验中,我们通过一个实际的项目来展示多态性的应用。
我们选择了一个图书管理系统作为例子,其中包括了不同类型的图书,如小说、教材和杂志。
通过使用多态性,我们可以统一管理这些不同类型的图书,并实现一套通用的借阅和归还功能。
这样,无论新增了多少种类型的图书,我们都可以轻松地扩展和修改代码。
结论:通过本次实验,我们深入了解了多态性的概念和应用,并通过一系列的实验来验证和探究多态性在程序设计中的作用。
多态性的使用可以使代码更加灵活和可扩展,但也需要在设计和实现中进行合理的权衡。
在实际项目中,多态性可以帮助我们更好地管理和处理不同类型的对象,提高代码的可维护性和可扩展性。
运算符重载及多态第五章哈尔滨工程大学
D1 d1; pb0=&b0;
void display()
pb0->display();
int Hour,Minute,Second; };
哈尔滨工程大学课件
运算符重载—重载为成员函数
Clock Clock::operator ++() { Second++;
if(Second>=60) { Second=Second-60;
Minute++; if(Minute>=60) { Minute=Minute-60;
complex operator + (complex c2); complex operator - (complex c2); void display()
{cout<<real<<", "<<imag<<endl;} private:
double real,imag; };
哈尔滨工程大学课件
运算符重载—重载为成员函数
形参的成员函数。 重载后: oprd++ 相当于 oprd.operator ++(0)
哈尔滨工程大学课件
运算符重载—重载为成员函数
例:将运算符前置++和后置++重载为时钟类的成员函数。 操作数:时钟类的对象
功能:实现时间增加1秒钟 class Clock {public:
Clock(int NewH=0, int NewM=0, int NewS=0); void ShowTime(); Clock operator ++(); Clock operator ++(int); private:
实验7多态性和运算符重载
实验7多态性和运算符重载实验7 运算符重载一、实验目的1.了解多态性;2.掌握算术运算符和关系运算符的重载;3.掌握运算符重载的方法;4.掌握作为成员函数的运算符重载和作为友元函数的运算符重载的不同特点。
二、相关知识1.概念理解多态是指类族中具有相似功能的不同函数使用同一名称来实现,从而可以使用相同的调用方式来调用这些具有不同功能的同名函数。
C++中的多态的实现形式:函数重载、运算符重载、虚函数等。
函数重载是指同一个函数可以操作于不同类型的对象:运算符重载是对已有的运算符赋予多重含义,使用已有运算符对用户自定义类型(比如类)进行运算操作,运算符重载实际上是函数重载;虚函数是实现类族中定义于不同类中的同名成员函数的多态行为。
多态从实现的角度可以分为两类:编译时的多态和运行时的多态,前者是在编译过程中确定了同名操作的具体操作对象,而后者则是在程序运行过程中才动态地确定所针对的具体对象。
这种确定操作的具体对象的过程就是联编。
编译时的多态通过静态联编解决,如函数重载或运算符重载,它们在编译、链接过程中,系统就可以根据类型匹配等特征确定程序中操作调用与执行代码的关系,即确定了某一个同名标识到底要调用哪一段程序代码。
运行时的多态通过动态联编实现,虚函数是实现动态联编的基础,若定义了虚函数就可以通过基类指针或引用实现,执行时会根据指针指向的对象所属的类,决定调用哪个函数。
虚函数具有继承性,其本质不是重载声明而是覆盖。
纯虚函数是在基类中说明的虚函数,它在该基类中可以不给出函数体,要求各派生类根据实际需要编写自己的函数体。
带有纯虚函数的类是抽象类,抽象类的主要作用是通过它为一个类族建立一个公共的接口,使它们能够更有效地发挥多态特性。
2.运算符重载运算符重载是指同样的运算符可以施加于不同类型的操作数上面,使同样的运算符作用于不同类型的数据导致不同类型的行为。
运算符重载的实质就是函数重载。
在实现过程中,首先把指定的运算符表达式转化为对运算符函数的调用,运算对象转化为函数的形参,然后根据实参的类型来确定需要调用的函数,这个过程是在编译过程中完成的。
多态和虚函数、运算符重载
(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函数,例。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
实验十二虚函数和多态性一、实验目的1、学习虚函数的定义和多态性的概念。
2、理解前捆绑与后捆绑的异同。
3、学习多态编程。
4、理解如何重新定义(重载)运算符以使用新类型。
5、理解如何将对象从一个类转换为另一个类。
6、了解何时重载以及何时不重载运算符。
二、实验内容及步骤1、填空(1)关键字引入了重载运算符函数定义。
(2)为在类对象上使用运算符,它们必须重载,但运算符和例外。
(3)通过重载运算符不能修改运算符的、和。
(4)不能重载的C++运算符是、、、和。
(5)动态联编要满足两个条件,它们是___________, ___________.(6)在C++中,定义重载函数时,应至少使重载函数的参数个数或参数类型___________;在基类和派生类中,成员函数的覆盖是指___________.(7)设px是指向一个类动态对象的指针变量,则执行“delete px;”语句时,将自动调用该类的_________________.(8)不能重载的C++运算符是、、、和。
(9)假定要对类AB定义加号操作符重载成员函数,实现两个AB类对象的加法,并返回相加结果,则该成员函数的声明语句为:__________ 。
(10)在一个派生类中,对基类成员、类对象成员和非类对象成员的初始化次序是先_______,后_______,最后为_______。
(11)动态联编要满足两个条件,它们是___________, ___________.(12)面向对象的程序设计有四大特征,它们是抽象,封装, ___________, ___________. (13)在C++类中,有一种不能定义对象的类,这样的类只能被继承,称之为___________,定义该类至少具有一个___________.(14)在基类中被说明为虚函数的类的成员函数必须在每个派生类中说明为虚函数,才能具有多态的特征。
______________(15)派生类的成员函数可以直接访问基类的所有成员。
_____________(16)运算符重载的目的是,运算符重载的形式有和。
(17)利用成员函数对双目运算符重载,其左操作数为_____________,右操作数为_____________。
(18)运算符重载仍然保持其原来的优先级、_____________和_____________。
(19)为了满足运算符“+”的可交换性,必须将其重载为_____________。
二、程序分析题(1)请写出以下程序执行结果,并分析加法可交换性。
#include<iostream.h>class Sample {int n;public:Sample(){}Sample(int i){n=i;}friend Sample operator+(Sample,Sample);void disp() {cout<<“n=”<<n<<endl;} }Sample operator+(sample s1,Sample s2) {return sample(S1.n+s2.n);} void main() {Sample S1(2),s2(5),s3;cout<<”S1:”;S1.disp();cout<<”s2:”;s2.disp();s3=S1+S2;cout<<”s3:”;s3.disp();S3=S2+S1;cout<<”s3:”;s3.disp();}(2)有如下程序:#include<iostream.h>class BASE{char c;public:BASE(char n):c(n){}virtual~BASE(){cout<<c;};class DERIVED:public BASE{char c;public:DERIVED(char n):BASE(n+1),c(n){}~DERIVED(){cout<<c;};int main(){ DERIVED("X");return 0;}执行上面的程序将输出()(3)下面程序的输出结果为_____________#include <iostream.h>#include <string.h>#include <stdlib.h>class Vehicle{protected:char *msg;public:Vehicle(char *s){int len=strlen(s);msg=new char[len+1];if(!msg){cout<<"memory allocation failure!"<<endl;exit(1);}strcpy(msg, s);}virtual ~Vehicle(){if(msg)delete []msg;msg=NULL;}virtual void show(){cout<<"Vehicle: "<<msg<<endl;} };class Car: public Vehicle{public:Car(char *s):Vehicle(s){}virtual void show(){cout<<"Car: "<<msg<<endl;}}; class Truck: public Vehicle{public:Truck(char *s):Vehicle(s){}virtual void show(){cout<<"Truck: "<<msg<<endl;}}; class Boat: public Vehicle{public:Boat(char *s):Vehicle(s){}virtual void show(){cout<<"Boat: "<<msg<<endl;}}; int main(){Vehicle v("vehicle");Car c("car");Truck t("truck");Boat b("boat");Vehicle *ptr[]={&v, &c, &t, &b};for(int i=0; i<4; i++)ptr[i]->show();return 0;}(4)下面程序的运行结果是___________.#include <iostream>using namespace std;class A{public:A(){cout<<"A::A() called.\n";}virtual ~A(){cout<<"A::~A() called.\n";}};class B:public A{ public:B(int i){cout<<"B::B() called.\n";buf=new char; }virtual ~B(){delete []buf;cout<<"B::~B() called.\n";}private:char *buf;};void fun(A *a){delete a; }void main() {A *a=new B(15);fun(a); }(5)下面程序的输出结果是:_______________________ class CLS_5161{private:int x,y;public:CLS_5161();CLS_5161(int _x);CLS_5161(int _x,int _y);virtual ~CLS_5161();};//CLS_5161.cpp#include "CLS_5161.h"#include "iostream.h"CLS_5161::CLS_5161(){cout<<"no parameter"<<endl;}CLS_5161::CLS_5161(int _x){x = _x;cout<<"parameter is "<<x<<endl;}CLS_5161::CLS_5161(int _x,int _y ){x = _x;y = _y;cout<<"parameter is "<<x<<" and "<<y<<endl;}CLS_5161::~CLS_5161(){cout<<"This is ~CLS_5161()"<<endl;}//no1.cpp#include "iostream.h"#include "CLS_5161.h"void main(){CLS_5161 c1,c2(1),c3(1,2);}(6)以下程序的执行结果是_______________________。
#include<iostream.h>class Sample {int n;public:Sample(){)Sample(int m){n=m;}int &operator--(int){ n--;return n;}void disp() { cout<<”n=”<<n<<endl;) } void main() {Sample s(10);(S--)++;S.disp();(7)以下程序的执行结果是_______________________。
#include<iostream.h>class Sample {private:int x;public:Sample(){x=0;}void disp(){cout<<”x=”<<x<<endl;}void 0perator++(){x+=10;} } ;void main() {Sample obj;obj.disp();obj++;cout<<“执行bj++之后”<<endl ;obj.disp();}三、综合题1、在什么情况下,在C++中使用名称operator/ ?举一程序例说明。