实验5-运算符重载、继承 ( 1 )
- 格式:doc
- 大小:46.00 KB
- 文档页数:3
运算符重载实验报告运算符重载实验报告引言:运算符重载是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。
实验5 运算符重载的应用实验5 运算符重载的应用5.1实验目的1.掌握用成员函数重载运算符的方法2.掌握用友元函数重载运算符的方法5.2实验内容与步骤1.机实验题一定义一个复数类,通过重载运算符:*,/,直接实现二个复数之间的乘除运算。
编写一个完整的程序,测试重载运算符的正确性。
要求乘法“*”用友元函数实现重载,除法“/”用成员函数实现重载。
⑴分析两复数相乘的计算公式为:(a+b i)*(c+d i)=(ac–bd )+(ad+bc) i两复数相除的计算公式为:(a+b i)/(c+d i)=(ac+bd)/(c*c+d*d)+(bc-ad)/(c*c+d*d) i复数类及运算符重载函数可定义为:class Complex{float Real, Image;public:Complex(float r=0,float i=0) { Real=r;Image=i;}void Show(){cout <<"Real="<<Real<<'\t'<<"Image="<<Image<<'\n';}friend Complex operator *(Complex &, Complex &);Complex operator /(Complex &); //重载运算符+ };Complex operator *( Complex &c1,Complex &c2){Complex t;t.Real=c1.Real * c2.Real - c1.Image * c2.Image;t.Image = c1.Image*c2.Real +c1.Real* c2.Image;return t;}Complex Complex::operator /(Complex &c){C++面向对象程序设计实验指导Complex t;t.Real =(Real *c.Real+ Image * c.Image)/(c.Real*c.Real+ c.Image * c.Image);t.Image = (Image *c.Real - Real * c.Image)/(c.Real*c.Real+ c.Image * c.Image);return t;}⑵上机要求增加重载复数的加法和减法运算符的功能,实现两个复数的加法,一个复数与一个实数的加法;两个复数的减法,一个复数与一个实数的减法。
高级程序设计语言C++实验报告学号:姓名:日期:实验运算符重载1.实验目的1)进一步了解运算符重载的概念和使用方法。
2)掌握几种常用的运算符重载的方法。
3)了解转换构造函数的使用方法。
4)了解在Visual C++6.0环境下进行运算符重载要注意的问题。
2.实验内容和步骤1)定义一个复数类Complex,重载运算符“+”和“-”,使之能用于复数的加和减,分别求两个复数的和和差。
要求“+”运算符重载函数作为友元函数,“-”运算符重载作为成员函数。
源程序:运行结果2)定义一个复数类Complex,重载运算符“+”使之能够完成复数的加法运算,参加运算的两个运算量可以都是类对象,也可以其中一个是整数,顺序任意(即c1+i,和i+c1都能实现,这里c1是复数类对象,i是整数)。
编程序,分别求两个复数之和、整数和复数之和,满足交换律。
源程序:运行结果3)编写程序,处理一个复数与一个double数相加的运算,结果存放在一个double型的变量d1中,输出d1的值,再以复数形式输出此值。
定义Complex(复数)类,在成员函数中包含重载类型转换运算符:operator double( ) {return real;}源程序:运行结果4) 定义一个Teacher(教师)类和一个Student(学生)类,二者有一部分数据成员是相同的,例如num(号码),name(姓名),sex(性别)。
编写程序,将一个Student对象(学生)转换为Teacher(教师)类,只将以上3个相同的数据成员移植过去。
可以设想为:一位学生大学毕业留校担任老师,他原有的部分数据仍然是有用的,应当保留。
源程序:运行结果3.实验中遇到的问题及解决方法。
实验5 运算符重载1、实验目的和要求:掌握运算符重载的语法要点,学会运算符重载的编程方法。
2、实验内容(1)先读程序,写出程序的输出结果,再运行程序验证程序的输出。
用友元重载方式重新编写程序。
#include <iostream>using namespace std;class V ector{ public:V ector(){}V ector(int i,int j) {x=i;y=j;}friend V ector operator+=(V ector v1,V ector v2){ v1.x+=v2.x;v1.y+=v2.y;return v1;}V ector operator-=(V ector v){ V ector temp;temp.x=x-v.x;temp.y=y-v.y;return temp;}void display(){ cout<<"("<<x<<","<<y<<")"<<endl;}private:int x,y;};void main(){V ector v1(1,2),v2(3,4),v3,v4;v3=v1+=v2;v4=v1-=v2;cout<<"v1=";v1.display();cout<<"v2=";v2.display();cout<<"v3=";v3.display();cout<<"v4=";v4.display();}(2)定义一个有理数类,重载比较运算符.写一个完整的程序,进行数据成员的设置和输出。
class rational{private:long denom,den;//denom为分子,den为分母public:rational(int num=0, int denom=1;int operator<(rational r) const;int operator<=(rational r) const;int operator= =(rational r) const;int operator!=(rational r) const;//这里增加赋值和读出函数}(3) 设计集合类(Set),用运算符重载实现并(+),差(—),交(×)等操作,并重载=和-= ,实现Set S1,S2;… s1 = s2; 和S1-=S2;集合S1中去掉S2中存在的元素的操作。
运算符重载继承运算符重载是面向对象编程中的一个重要概念,它允许我们对已有的运算符进行重新定义,使其可以用于自定义类型的对象。
继承则是面向对象编程中的另一个重要概念,它允许我们创建一个新的类,该类可以继承已有类的属性和方法。
在面向对象编程中,运算符重载和继承是两个不同的概念,但它们通常会一起使用,以提供更灵活和强大的功能。
让我们来了解一下运算符重载。
在面向对象编程中,运算符重载允许我们对已有的运算符进行重新定义,以适应自定义类型的对象。
例如,我们可以对两个自定义对象进行相加操作,或者对自定义对象进行比较操作。
这样,我们就可以使用常用的运算符来操作自定义类型的对象,使代码更加简洁和易读。
继承则是面向对象编程中的另一个重要概念。
通过继承,我们可以创建一个新的类,该类可以继承已有类的属性和方法。
这样,我们就可以重用已有类的代码,并且可以在新的类中添加或修改一些功能,以满足特定的需求。
继承使代码更加模块化和可维护,同时也提高了代码的复用性。
继承和运算符重载的结合使用可以为我们提供更强大和灵活的编程能力。
通过继承已有类的属性和方法,我们可以在新的类中重新定义运算符,以适应自己的需求。
这样,我们就可以使用常用的运算符来操作自定义类型的对象,使代码更加简洁和易读。
同时,我们还可以在新的类中添加或修改一些功能,以满足特定的需求。
总结一下,运算符重载和继承是面向对象编程中的两个重要概念。
运算符重载允许我们对已有的运算符进行重新定义,以适应自定义类型的对象。
继承则允许我们创建一个新的类,该类可以继承已有类的属性和方法。
通过继承和运算符重载的结合使用,我们可以提供更强大和灵活的编程能力,使代码更加简洁和易读。
一、实验目的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. 运算符重载的实际应用运算符重载在实际编程中具有以下优势:- 提高代码可读性:使用自定义类型时,可以像操作基本数据类型一样使用运算符,提高代码的可读性。
C++实验5运算符重载
实验5 运算符重载
一、实验目的
1.理解运算符重载概念;
2.学会使用运算符重载;
3.练习类和对象的使用。
二、实验内容
设计一个日期类Date,包括年、月、日等私有数据成员。
要求实现日期的基本运算,如某日期加上天数、某日期减去天数、两日期相差的天数等。
三、实验要求
在Date类中设计如下重载运算符函数:
Date operator+(int days):返回某日期加上天数得到的日期
Date operator-(int days):返回某日期减去天数得到的日期int operator-(Date&b):返回两日期相差的天数
在实现这些重载运算符函数时调用以下私有成员函数:
leap(int):判断指定的年份是否为闰年
dton(Date &):将指定日期转换成从0年O月O日起的天数
ntod(int):将指定的0年O月O日起的天数转换成对应的日期
提示:可定义一个二维数组,存放闰年和非闰年每个月的天数,用于后面的计算,int day_tab[2][12]={{31,28,31,30,3l,30,3l,3l,30,31,30,31),
{31,29,31,30,31,30,31,31,30,31,30,31}};
// day_tab二维数组存放各月天数,第一行对应非闰年,第二行对应闰年。
实验六运算符重载(2学时)一、实验目的1.掌握运算符重载的规则。
2.掌握用成员函数、友元函数重载运算符的特点。
3.掌握几种常用的运算符重载的方法。
二、实验内容1.阅读下面的程序,写出程序运行的结果。
(1)#include<iostream.h>class ABC{int a,b,c;public:ABC(int x,int y,int z):a(x),b(y),c(z){}friend ostream &operator<<(ostream &out,ABC& f);};ostream &operator<<(ostream &out,ABC& f){out<<"a="<<f.a<<endl<<"b="<<f.b<<endl<<"c="<<f.c<<endl;return out;}int main(){ABC obj(10,20,30);cout<<obj;return 0;}(2) 写出运行结果。
将成员函数重载形式改为友元函数重载形式,友元函数重载形式改为成员函数重载形式#include<iostream.h>class Number{int n;public:Number(int x):n(x){}Number& operator++(){ ++n; return *this; }Number& operator++(int){ n++; return *this;}friend Number &operator--(Number &o);friend Number &operator--(Number o,int);void display(){cout<<"This Number is: "<<n<<endl;}};Number &operator--(Number &o){--o.n; return o; }Number &operator--(Number o,int){o.n--; return o; }int main(){Number N1(10);++ ++ ++N1;N1.display();N1++;N1.display();--N1;N1.display();N1-- -- --;N1.display();return 0;}2.设计并实现一个日期类Date,要求:(1)可以建立具有指定日期(年、月、日)的Date对象,默认日期是2009.1.1。
运算符重载运算符重载学习运算符重载,让运算符能做⼀些原来做不了的事情,⽅便它的使⽤⼀、运算符重载的概念1、什么是运算符重载1.重载:重新载⼊,就像之前学的函数重载,对⼀个已有的函数赋值⼀个新的定义,因此同⼀个函数名就可以有不同的含义。
2.运算符也是可以重载的,⽐如cout在输出⼀个变量的时候,能接受不同类型的数据并输出,他就是重载了<<运算符,这个就是运算符重载3.所以运算符重载指的是对已有的运算符重新定义新的运算规则,以适应不同的数据类型,当然重载之后之前的运算规则还是有的2、为什么要进⾏运算符重载1.运算符重载之后可以让运算符去适应不同的数据类型,对于基本数据类型,系统给出了运算符的操作规则,对于⾃定义数据类型来说,系统不知道该给出什么规则class student{int id;int age;char name[20];public:student(int id,int age,const char* name){this->id=id;this->age=age;strcpy(this->name,name);}}student stu1(1,23,"张三");student stu2(2,24,"李四");stu1+stu2;//如果是这样相加,那么应该加的是什么呢?编译器是不知道的,所以编译器就提供了运算符重载这个机制,让⽤户⾃定义运算符的运算规则⼆、运算符重载1、运算符重载类中定义1.关键字:operator,通过关键字来定义运算符重载(跟写个函数⼀样)2.定义:函数返回值类型 operator 要加载的运算符(参数列表){函数体;}这⾥把运算符的使⽤,理解为调⽤函数,只是和平时的调⽤函数有⼀点区别#include<iostream>#include<string>using namespace std;class student{int id;int age;string name;public:student(int age){this->age = age;id = 1;name = "sss ";}student(int id, int age, string name){this->id = id;this->age = age;this->name = name;}void showstudent(){cout << id << "\t" << age << "\t" << name << endl;}student operator+(student& p1)//这个函数会返回⼀个新的对象{int x=this->age + p1.age;student p(x);return p;//返回的是⼀个对象,会调⽤拷贝构造}int operator-(int x){return this->id - x;}void operator+(student&p2){cout << this->id + p2.id << endl;}};//1.操作这个运算符之后,返回值类型是什么int main(){student p1(0, 1, "yunfei");int x = p1.operator-(1);cout << x << endl;student stu1(1, 23, "张三");student stu2(2, 24, "李四");//student stu3 = stu1.operator+(stu2);//student stu3 = stu1 + stu2;stu1 + stu2;//stu3.showstudent();system("pause");return 0;}注意:因为我们这个运算符是在类中写的,所以是通过对象调⽤的,那么this指针会占⼀个参数,⽽且是第⼀个参数,也就是说我们重载⼀个运算符,是在类中,⽽这个运算符是个单⽬运算符,那么参数列表就不⽤写东西了,是双⽬运算符,那么就需要传另⼀个参数进来绝⼤部分的运算符重载都可以参照上⾯这个+号重载2、运算符重载的特点1.⼏乎所有的运算符都可以被重载,除了 . :: ()?() ) sizeof()2.运算符重载基本出现在类中和结构体中3.运算符可以理解为函数的⼀个表现3、运算符重载的注意事项1.重载运算符,这个重载的运算符还是满⾜原来的原则,但不能说重载+号,结果做的事-号的事,这样会使运算符的运⽤上增加很⼤的难度2.运算符重载的参数,类中重载调⽤对象会占⼀个参数,就是this会占⼀个参数,参数列表就是⽤来表⽰运算符的操作的3.对于运算符重载的调⽤,可以直接使⽤运算符,也可以通过对象 . 出来调⽤4.考虑返回值,不同的运算符有不同的返回值,要记得满⾜运算符原来的规则4、使⽤友元函数,实现运算符重载1.类在已经实现且部分修改的情况下下,需要进⾏运算符重载,就可以通过友元的⽅式来进⾏重载#include<iostream>#include<string>using namespace std;class person{int id;int age;string name;public:person(int id, int age, string name){this->id = id;this->age = age;this->name = name;}void showperson(){cout << id << "\t" << age << "\t" << name << endl;}friend int operator+(person&p1, person&p2);};//形参使⽤的是类对象的引⽤,在实参传对象的时候不会调⽤拷贝构造int operator+(person&p1, person&p2){return p1.id + p2.id;}//1.操作这个运算符之后,返回值类型是什么int main(){person stu1(1, 23, "张三");person stu2(2, 24, "李四");int x = operator+(stu1, stu2);//显⽰调⽤int y = stu1 + stu2;//隐式调⽤cout << x << endl << y << endl;system("pause");return 0;}容器:#include<iostream>#include<vector>using namespace std;int main(){//int 是v1这个容器存的类型vector<int> v1;for (int i = 0; i < 10; i++){//push_back()是⼀个函数,功能是尾插元素v1.push_back(i + 1);}for (int i = 0; i < 10; i++){cout << v1[i] << "\t";}system("pause");return 0;}左移右移运算符重载:#include<iostream>using namespace std;class person{int id;public:person(int id){this->id = id;}friend ostream& operator<<(ostream& os, person& p1);friend istream & operator>>(istream & in, person & p2);};//左移右移运算符重载,必须在类外重载,通过友元实现ostream& operator<<(ostream& os, person& p1)//左移运算符{os << p1.id << endl;return os;//返回的是⼀个cout,⽽且只能⽤引⽤}istream & operator>>(istream & in, person & p2)//右移运算符{in >> p2.id;return in;}int main(){person p1(10), p2(20);cin >> p1 >> p2;cout << p1 << endl << p2 << endl;system("pause");return 0;}前++,后++运算符重载:#include<iostream>using namespace std;class person{int id;public:person(int id){this->id = id;}person& operator++()//前++{this->id++;return *this;}person& operator++(int)//后++,int是⼀个占位符,⽤来区分前++和后++的{static person temp = *this;//引⽤不能返回局部变量,要⽤静态变量this->id++;return temp;}friend ostream& operator<<(ostream& os, person& p1);friend istream & operator>>(istream & in, person & p2);};//左移右移运算符重载,必须在类外重载,通过友元实现ostream& operator<<(ostream& os, person& p1)//左移运算符{os << p1.id << endl;return os;//返回的是⼀个cout,⽽且只能⽤引⽤}istream & operator>>(istream & in, person & p2)//右移运算符{in >> p2.id;return in;}int main(){person p1(10), p2(20);//cin >> p1 >> p2;//cout << p1 << endl << p2 << endl;cout << p1 ;//10cout << p1++ ;//10cout << p1 ;//11cout << ++p1 ;//12cout << p1 ;//12system("pause");return 0;}等号运算符重载:#include<iostream>using namespace std;class person{char* name;public:person(const char* name){this->name = new char[strlen(name) + 1];strcpy(this->name, name);}person& operator=(person&p1)//⽤不⽤引⽤传参,要看返回的对象会不会消失 {if (this->name != NULL){delete[]this->name;this->name = NULL;}this->name = new char[strlen() + 1];strcpy(this->name, );return *this;}void show(){cout << name << endl;}~person()//如果有申请函数,就要加上析构函数{if (name != NULL){delete[]name;name = NULL;}}};int main(){{person p1("张三"), p2("李四"), p3("王五");p1 = p2 = p3;p1.show();p2.show();p3.show();}//加上⼤括号,让对象死亡,就能调⽤析构函数system("pause");return 0;}智能指针和==号运算符重载:#include<iostream>using namespace std;class person{int id;public:person(int id){this->id = id;}void show(){cout << id << endl;}bool operator==(person& p){return this->id == p.id;}~person(){cout << "person的析构函数" << endl;}};class smartpointer{person* ps;//包含你要new出来的对象的类的指针public:smartpointer(person* p){ps = p;}//重载->person* operator->()//传回来的是地址,不是对象,不⽤引⽤{return ps;}//重载*person& operator*()//返回的是对象,会调⽤拷贝构造,所以⽤返回值⽤引⽤,就不会再调⽤拷贝构造了 {return *ps;//得到⼀个对象,}~smartpointer(){if (ps != NULL){delete ps;ps = NULL;}}};int main(){{smartpointer p(new person(5));p->show();(*p).show();person p1(1), p2(3);cout << (p1 == p2) << endl;}//有三个对象,所以析构函数执⾏了三次system("pause");return 0;}[]运算符重载:#include<iostream>using namespace std;class person{char* name;public:person(const char* name){this->name = new char[strlen(name) + 1];strcpy(this->name, name);}char& operator[](int index){return name[index];}~person(){if (name != NULL){delete[]name;name = NULL;}cout << "这是析构函数" << endl;}};int main(){person p("asdfg");cout << p[3] << endl;system("pause");return 0;}c++引⽤作为函数返回值:1.以引⽤返回函数值,定义函数时需要在函数名前加 &2.⽤引⽤返回⼀个函数值的最⼤好处是,在内存中不产⽣被返回值的副本3.返回值为引⽤的时候,返回的是⼀个地址,隐形指针4.当返回值不是引⽤时,编译器会专门给返回值分配出⼀块内存的引⽤作为返回值,必须遵守以下规则:(1)不能返回局部变量的引⽤。
南昌航空大学实验报告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;}五、程序调试经调试无误后,运行的结果为:六、实验总结通过这次的试验,我明显的感觉到自己对这方面的知识掌握的还不够熟练,不能顺利地、流畅地运用这方面的知识,因为我没有在规定的时间内完成程序的设计,课后还是要多复习。
实验五运算符重载、继承
●实验目的
1、了解类的两种使用方式。
2、学习从现有类派生出新类的方式。
3、了解在派生类中如何使用基类的成员。
4、了解基类成员在派生类中的访问控制。
5、掌握运算符重载的方法。
●实验内容
1、从类Person中派生出一个教师类,新增的属性有专业(Specialty)、职称(Position)和主讲课程(MajorCourse,一门),并为这些属性定义相应的方法。
[实现要求]
Person类的设计如下,请将空白处补充完整。
class Person
{
string Name;
int Age;
string Sex;
public:
void Register(char *name,int age,char *sex)
{
;
Age=age;
Sex=sex;
}
string GetName() { }
string GetSex() { return Sex; }
int GetAge() { }
void ShowMe()
{
cout<<GetName()<<"\t"<<GetSex()<<"\t"<<GetAge()<<"\t";
}
};
教师类由Person类共有派生出来,主函数设计如下:
int main()
{
Teacher t;
t.ShowMe(); //创建Teacher类对象t后直接显示各成员的值,在Teacher类中应有不
//带参数的构造函数去初始化各个成员的值,使其显示运行结果的第一行t.TeacherRegister("张三",40, "f","计算机","副教授","C++");
t.ShowMe();
return 0;
}
运行结果如下:
XXX m 0 XXX XXX XXX
张三 f 40 计算机副教授C++
[思考问题]
①在Teacher类中是否要需要重新定义ShowMe成员函数?不重新定义ShowMe成员函数能否得到上述要求的运行结果?为什么?
2、从Point类中派生出一个Line类。
Line类增加一个数据成员EndPoint,计算线的长度。
[实现提示]
Point类可以按下面方式进行设计:
class Point{
int x,y;
public:
Point(int a=0,int b=0){SetPoint(a,b);}
void SetPoint(int a,int b); //设置点的坐标值
int GetX(){return x;}
int GetY(){return y;}
void Print(); //显示点的坐标值
};
Line类增加一个数据成员EndPoint为Point类对象,注意在设计Line类的构造函数时应为其基类和对象成员EndPoint提供形参。
为了检验Line类的功能,主函数按如下方式设计:
int main(){
Line line(1,1,10,10);
cout<<"Line line:";
line.Print();
cout<<"\n线line的长度:";
cout<<line.Length()<<endl;
return 0;
}
运行结果如下:
Line line:开始点:[1,1];结束点:[10,10]
线line的长度:12.7279
3、对实验4中的第3题设计的Time类进行修改,通过重载“+”、“-”运算符直接进行时间的加减运算。
[实现要求]
(1)用友元函数来实现运算符的重载
(2)加法运算符可以是两个Time对象进行相加,也可以是一个表示秒数的int型数据加
上一个Time对象,可以是Time对象加上int型数据,得到的结果都是Time类型的对象。
(3)减法运算符可以是两个Time对象进行相减,也可以是Time对象减去一个表示秒数
的int型数据,得到的结果都是Time类型的对象。
按照以上要求,主函数设计如下:
void main()
{
Time t1(2,34),t2,t3;
t2.SetTime(13,23,34);
cout<<"\nt1+t2:";
t3=t1+t2; //两个Time类对象相加
t3.print_24();
cout<<"\nt1+65:";
t3=t1+65; //Time类对象加上65秒
t3.print_24();
cout<<"\n65+t1:";
t3=65+t1; //65秒加上Time类对象
t3.print_24();
cout<<"\nt1-t2:";
t3=t1-t2; //两个Time类对象相减
t3.print_24();
cout<<"\nt1-70:";
t3=t1-70; //Time类对象减去70秒
t3.print_24();
}
运行结果如下:
t1+t2:15:57:34
t1+65:02:35:05
65+t1:02:35:05
t1-t2:10:49:34
t1-70:02:32:50
[思考问题]
①各个运算符重载函数能不能用成员函数来实现?为什么?。