C++面向对象入门：实验三

一、实验目的

1. 理解C++运算符重载的基本概念和语法规则；

2. 掌握以成员函数形式和友元函数形式重载运算符的方法；

3. 学会使用重载算数运算符+-*/和自增运算符++；

4. 了解运算符在实际编程中的应用场景。

二、实验内容

1. 输入并编译程序，运行出结果，并解释每行语句作用。

//以成员函数形式重载运算符+，实现两个字符串的加法运算（字符串连接）
#include<iostream>
#include<string.h>
using namespace std;
class mystring{
	char ms[1024];
public:
	mystring(const char* s){strcpy(ms,s);}//构造函数，用字符串初始化ms数组
	mystring &operator+(mystring &t){//重载+运算符，实现字符串连接
		strcat(ms,t.ms);//将t的字符串连接到当前字符串末尾
		return* this;}//返回当前对象的引用
	char* getstring(){return ms;}//返回内部字符数组指针
};
int main(){
	mystring s1("aaa"),s2("bbb");//创建两个mystring对象
	s1=s1+s2;//使用重载的+运算符连接字符串
	cout<<s1.getstring()<<endl;//输出连接后的结果"aaabbb"
	system("pause");
	return 0;}

运行结果

aaabbb

2. 输入并编译程序，运行出结果，并解释每行语句作用。

#include<iostream>
using namespace std;
class Complex{
public:
	Complex(){real=0;imag=0;}//默认构造函数
	Complex(double r,double i){real=r;imag=i;}//带参构造函数
	friend Complex operator+(Complex &c1,Complex &c2);//声明友元加法运算符
	friend Complex operator-(Complex &c1,Complex &c2);//声明友元减法运算符
	friend Complex operator*(Complex &c1,Complex &c2);//声明友元乘法运算符
	friend Complex operator/(Complex &c1,Complex &c2);//声明友元除法运算符
	void display();//声明显示函数
private:
	double real;//实部
	double imag;//虚部
};
//下面定义成员函数
Complex operator+(Complex &c1,Complex &c2){//复数加法：(a+bi)+(c+di)=(a+c)+(b+d)i
	return Complex(c1.real+c2.real,c1.imag+c2.imag);}
Complex operator-(Complex &c1,Complex &c2){//复数减法：(a+bi)-(c+di)=(a-c)+(b-d)i
	return Complex(c1.real-c2.real,c1.imag-c2.imag);}
Complex operator*(Complex &c1,Complex &c2){//复数乘法：(a+bi)*(c+di)=(ac-bd)+(ad+bc)i
	return Complex(c1.real*c2.real-c1.imag*c2.imag,c1.imag*c2.real+c1.real*c2.imag);}
Complex operator/(Complex &c1,Complex &c2){//复数除法：(a+bi)/(c+di)=[(ac+bd)+(bc-ad)i]/(c²+d²)
	return
Complex((c1.real*c2.real+c1.imag*c2.imag)/(c2.imag*c2.imag+c2.real*c2.real),(c1.imag*c2.real-c1.real*c2.imag)/(c2.imag*c2.imag+c2.real*c2.real));}
void Complex::display(){//输出复数格式：(实部,虚部i)
	cout<<"("<<real<<","<<imag<<"i)"<<endl;}
int main(){
	Complex c1(3,4),c2(5,-10),c3;//创建复数对象
	cout<<"c1=";
c1.display();//输出c1: (3,4i)
	cout<<"c2=";
c2.display();//输出c2: (5,-10i)
	c3=c1+c2;
cout<<"c1+c2=";c3.display();//计算并输出加法结果
	c3=c1-c2;
cout<<"c1-c2=";c3.display();//计算并输出减法结果
	c3=c1*c2;
cout<<"c1*c2=";c3.display();//计算并输出乘法结果
	c3=c1/c2;
cout<<"c1/c2=";c3.display();//计算并输出除法结果
	system("pause");
	return 0;
}

运行结果

c1=(3,4i)
c2=(5,-10i)
c1+c2=(8,-6i)
c1-c2=(-2,14i)
c1*c2=(55,-10i)
c1/c2=(-0.2,0.4i)

3. 输入并编译程序，运行出结果，并解释每行语句作用。

#include<iostream>
using namespace std;
class Time{
	public:
		Time(){minute=0;sec=0;}//默认构造函数
		Time(int m,int s):minute(m),sec(s){}//带参构造函数，使用初始化列表
		Time operator++();//声明前置++运算符
		Time operator++(int);//声明后置++运算符
		void display(){cout<<minute<<":"<<sec<<endl;}
private:
	int minute;//分钟
int sec;//秒
};
Time Time::operator++(){//前置++实现
	if(++sec>=60){//秒数加1，如果达到60秒
		sec-=60;//秒数归零
		++minute;}//分钟数加1
	return* this;}//返回当前对象
Time Time::operator++(int){//后置++实现
	Time temp(*this);//保存原始值
	sec++;//秒数加1
	if(sec>=60){//如果达到60秒
		sec-=60;//秒数归零
		++minute;}//分钟数加1
	return temp;}//返回原始值
int main(){
	Time time1(34,59),time2;//创建时间对象
	cout<<"time1:";time1.display();//输出初始时间：34:59
	++time1;cout<<"++time1:";time1.display();//前置++，输出：35:0
	time2=time1++;//后置++，time2保存原值，time1自增
	cout<<"time1++:";time1.display();//输出自增后的time1：35:1
	cout<<"time2:";time2.display();//输出time2：35:0
	system("pause");
	return 0;
}

运行结果

time1:34:59
++time1:35:0
time1++:35:1
time2:35:0

4. 程序设计：定义一个计数器类Counter,对其重载运算符+。

#include<iostream>
using namespace std;
class Counter{
public:
	Counter(int c=0):count(c){}//构造函数，使用初始化列表
	Counter operator+(const Counter& other)const{//重载+运算符，const成员函数
		return Counter(count+other.count);}//返回新的Counter对象
	void display() const{//显示函数，const成员函数
	cout<<"Count:"<<count<<endl;}
private:
	int count;//计数值
};
int main(){
	Counter c1(3);//创建计数器c1，初始值3
	Counter c2(4);//创建计数器c2，初始值4
	cout<<"c1=";c1.display();//输出c1:Count:3
	cout<<"c2=";c2.display();//输出c2:Count:4
	Counter c3=c1+c2;//使用重载的+运算符
	cout<<"c3=";c3.display();//输出c3:Count:7
	return 0;
}

运行结果

c1=Count:3
c2=Count:4
c3=Count:7

三、实验总结

通过本次实验，我深入学习和实践了C++运算符重载的相关知识。掌握了运算符重载的两种形式，即成员函数形式和友元函数形式，理解它们各自的使用场景和区别。也理解了不同运算符的重载特点，还学会了使用const保证对象不会被改变，加深了对面向对象编程的理解。