A. 三维坐标点的平移（运算符重载）

题目描述

定义一个三维点Point类，利用友元函数重载"++“和”–"运算符，并区分这两种运算符的前置和后置运算。
在这里插入图片描述

要求如下：

1.实现Point类；

2.编写main函数，初始化1个Point对象，将这个对象++或–后赋给另外一个对象，并输出计算后对象的坐标信息。

输入

第1行：输入三个int类型的值，分别为一个Point对象p1的x,y,z坐标。

输出

第1行：Point对象p1后置++之后的坐标信息输出。

第2行：Point对象p1后置++操作后赋给另外一个Point对象p2的坐标信息。

第3行开始，依次输出前置++，后置–，前置–运算的坐标信息，输出格式与后置++一样。

输入样例1

10 20 30

输出样例1

x=11 y=21 z=31
x=10 y=20 z=30
x=11 y=21 z=31
x=11 y=21 z=31
x=9 y=19 z=29
x=10 y=20 z=30
x=9 y=19 z=29
x=9 y=19 z=29

提示

原值是最初输入的数值

第1行是p1后置++后，再输出

第2行是p1恢复原值，接着p1后置++同时复制给p2，p2输出

第3、4行是p1恢复原值，p1前置++同时输出，然后p1再输出

第5、6行是p1恢复原值，p1后置–后，再输出，接着输出一次原值

第7、8行是p1恢复原值，p1前置–同时输出，然后p1再输出

AC代码

#include<bits/stdc++.h>
using namespace std;

class Point {
	int x, y, z;
public:
	Point(int x=0,int y=0,int z=0):
		x(x),y(y),z(z){}

	friend Point operator++(Point&a){
		a.x++; a.y++; a.z++;
		return a;
	}


	friend Point operator++(Point& a, int) {
		Point TEMP = a;
		a.x++; a.y++; a.z++;
		return TEMP;
	}

	friend Point operator--(Point& a) {
		a.x--; a.y--; a.z--;
		return a;
	}


	friend Point operator--(Point& a, int) {
		Point TEMP = a;
		a.x--; a.y--; a.z--;
		return TEMP;
	}

	void show() {
		cout << "x=" << x << " " << "y=" << y << " " << "z=" << z << endl;
	}
};

int main() {
	int x, y, z;
	cin >> x >> y >> z;
	Point p1(x, y, z);
	p1++;
	p1.show();//line 1
	p1--;
	Point p2 = (p1++);
	p2.show();//line 2

	p1--;
	(++p1).show();//line 3
	p1.show();// line 4

	p1--;
	p1--;
	p1.show();
	p1++;
	p1.show();

	//p1--;
	(--p1).show();
	p1.show();
	return 0;

}

B. 矩阵相加（运算符重载）

题目描述

已知一个矩阵包含行数m、列数n、数值data三个属性，包含初始化、输出、相加等操作，要求

1、在类定义中，矩阵的data属性是一个整数指针型指针。只有创建对象时，根据外来输入的行数和列数，才把指针变成一个二维数组

2、用运算符重载的方法实现两个矩阵对象的相加，矩阵相加是指两个矩阵的每个位置上的两个元素相加

3、用构造函数实现对象的初始化，用输出函数实现矩阵的输出。提示：在构造函数内做输入可以减少很多麻烦

整数指针变成二位数组的参考代码

//m和n是行数和列数

int m, n;

int **data;

int i, j;

cin>>m>>n;
data=new int*[m]; //先创建m行
for(i=0;i<m;i++)
{ data[i]=new int[n]; } //再创建n列

for (i=0; i<m; i++)
for (j=0; j<n; j++)
cin>>data[i][j];

输入

第一行输入t表示t个实例

第二行输入第一个示例的矩阵的行数和列数，两个矩阵的行数和列数都是相同的

第三行起，输入第一个矩阵的具体数据

依次类推，输入第二个矩阵的具体数据

依次类推，输入下一个示例的数据

输出

输出每两个矩阵相加的结果，每个示例结果之间用一个回车分隔开

输入样例1

2
2 3
1 2 3
4 5 6
-1 -2 -3
6 5 4
2 2
11 22
33 44
55 66
77 88

输出样例1

0 0 0
10 10 10
66 88
110 132

AC代码

#include<bits/stdc++.h>
using namespace std;

class Matrix {
	int m, n, ** data;
public:
	Matrix(int m,int n):m(m),n(n) {
		data = new int* [m];
		for (int i = 0; i < m; i++)
			data[i] = new int[n];
		for (int i = 0; i < m; i++)
			for (int j = 0; j < n; j++)
				cin >> data[i][j];
	}

	Matrix(const Matrix& a) {
		m = a.m;
		n = a.n;
		data = new int* [m];
		for (int i = 0; i < m; i++)
			data[i] = new int[n];
		for (int i = 0; i < m; i++)
			for (int j = 0; j < n; j++)
				data[i][j] = a.data[i][j];
	}

	void print() {
		for (int i = 0; i < m; i++) {
			for (int j = 0; j < n; j++) {
				if (j)
					cout << " ";
				cout << data[i][j];
			}
			cout << endl;
		}
	}

	~Matrix(){
		for (int i = 0; i < m; i++)
			delete[]data[i];
		delete[]data;
	}


	Matrix operator +(const Matrix& a) {
		Matrix TEMP(a);
		for (int i = 0; i < m; i++)
			for (int j = 0; j < n; j++)
				TEMP.data[i][j] += data[i][j];
		return TEMP;
	}
};

int main() {
	int t;
	cin >> t;
	while (t--){
		int m, n;
		cin >> m >> n;
		Matrix a(m, n), b(m, n);
		(a + b).print();
	}
}

C. 字符串比较（运算符重载）

题目描述

定义一个字符串类str，用来存放不定长的字符窜，重载运算符"= =“、”<“、”>",用于两个字符窜的等于、小于和大于的比较运算。
在这里插入图片描述

要求如下：

1.实现str类；

2.编写main函数，初始化三个str对象A、B、C，然后用这三个对象去测试重载的运算符。如果A>B,则输出A的字符串；否则输出B的字符串。如果A<C，则输出A的字符串；否则输出C的字符串。如果B==C，则输出B的字符串；否则输出C的字符串。

输入

输入3行，每行为一个字符串，初始化三个str对象。

输出

输出比较之后的结果字符串，每个比较的结果一行。

输入样例1

i am a student
i love China
i love China

输出样例1

i love China
i am a student
i love China

AC代码

#include<bits/stdc++.h>
using namespace std;

class Str {
	char* p;
public:
	Str() {}
	Str(char* s) {
		int len = strlen(s) + 1;
		p = new char[len];
		strcpy(p, s);
		p[len - 1] = '\0';
	}

	friend bool operator>(Str& a, Str& b) {
		return strcmp(a.p, b.p) > 0;
	}

	friend bool operator<(Str& a, Str& b) {
		return strcmp(a.p, b.p) < 0;
	}

	friend bool operator==(Str& a, Str& b) {
		return strcmp(a.p, b.p) == 0;
	}

	~Str()
	{
		delete[]p;
	}

	void print() {
		cout << p << endl;
	}

};

int main() {
	string t;
	getline(cin, t);
	Str a((char*)t.c_str());
	getline(cin, t);
	Str b((char*)t.c_str());
	getline(cin, t);
	Str c((char*)t.c_str());

	if (a > b)
		a.print();
	else
		b.print();
	if (a < c)
		a.print();
	else c.print();

	if (b == c)
		b.print();
	else c.print();
	return 0;
}

D. 四进制加法（运算符重载）

题目描述

定义一个四进制的类，重定义“+”号实现四进制数的累加。

输入

第一行输入所需要的四进制数的个数

第二行开始，依次输入四进制数

输出

所有输入四进制数累加的和

输入样例1

3
13
2
21

输出样例1

102

AC代码

#include<bits/stdc++.h>
using namespace std;

class Myclass {
	int v;

	//4 -> 10
	int to_10(int value) {
		int sum = 0;
		string temp = to_string(value);
		for (int i = 0; i < temp.length(); i++) {
			sum += pow(4, i) * (temp[temp.length() - 1 - i] - '0');
		}
		return sum;
	}

	int to_4(int value) {
		string ans;
		while (value) {
			ans = to_string(value % 4) + ans;
			value /= 4;
		}
		return stoi(ans);
	}

public:
	Myclass() {
		cin >> v;
	}

	Myclass(int v) :v(v) {}


	Myclass operator+(const Myclass& a) {
		int sum = to_10(v) + to_10(a.v);
		sum = to_4(sum);
		return Myclass(sum);
	}

	int getValue() { return v; }

};

int main() {
	int n;
	cin >> n;
	vector<Myclass>v(n);
	Myclass sum(0);
	for (auto& it : v) {
		sum = sum + it;
	}
	cout << sum.getValue();

	return 0;
}

E. 学生生日差值计算（运算符重载）

题目描述

定义一个学生类Student，包含该学生的姓名、出生年、月、日，重定义 “-”号实现两个学生之间相差多少天的比较。并利用重载的“-”运算符，求所有学生中年龄相差最大的两个人的名字以及相差天数。

输入

第一行：输入所需要输入的学生个数；

第二行开始，依次输入每个学生的姓名、出生年、月、日。

输出

输出年龄相差最大的两个人的名字以及相差天数。

输入样例1

3
Tom 1995 1 1
Joe 1995 2 28
Jimmy 1996 1 8

输出样例1

Tom和Jimmy年龄相差最大，为372天。

AC代码

#include<bits/stdc++.h>
using namespace std;

class Date {
	int y, m, d;
public:
	Date() { cin >> y >> m >> d; }

	Date operator++() {
		int days[] = { 31,28,31,30,31,30,31,31,30,31,30,31 };
		if (y % 400 == 0 || (y % 4 == 0 && y % 100 != 0))
			days[1]++;
		d++;

		if (d > days[m - 1]) {
			d = 1;
			m++;
		}

		if (m > 12) {
			m = 1;
			y++;
		}

		return *this;
	}

	bool operator<(const Date& a) {
		if (y != a.y)
			return y < a.y;
		if (m != a.m)
			return m < a.m;
		if (d != a.d)
			return d < a.d;
	}

	bool operator==(const Date& a) {
		if (y != a.y)
			return false;
		if (m != a.m)
			return false;
		if (d != a.d)
			return false;
		return 1;
	}

	bool operator!=(const Date& a) {
		if (y != a.y)
			return 1;
		if (m != a.m)
			return 1;
		if (d != a.d)
			return 1;
		return 0;
	}

	int operator - (const Date& a) {
		int cnt = 0;
		Date a1 = *this;
		Date a2 = a;
		if (a2 < a1)
			swap(a1, a2);
		while (a1 != a2) {
			++a1; cnt++;
		}

		return cnt;
	}

};

class Student {
	string name;
	Date birthday;
public:
	Student(string n, Date b) :name(n), birthday(b) {

	}

	friend int operator-(Student& a, Student& b) {
		return a.birthday - b.birthday;
	}

	string getName() {
		return name;
	}

};

int main() {
	int n;
	cin >> n;
	vector<Student>v;
	for (int i = 0; i < n; i++) {
		string name;
		cin >> name;
		Date birthday;
		Student s(name, birthday);
		v.push_back(s);
	}

	int s1, s2;
	int cnt = -1;
	for (int i = 0; i < n - 1; i++)
		for (int j = i + 1; j < n; j++) {
			if (cnt < v[i] - v[j]) {
				cnt = v[i] - v[j];
				s1 = i; s2 = j;
			}
		}

	cout << v[s1].getName() << "和" << v[s2].getName() << "年龄相差最大，为" << cnt << "天。" << endl;

}

F. 时钟调整（运算符前后增量）

题目描述

假定一个时钟包含时、分、秒三个属性，取值范围分别为0_11，059，0~59，具体要求如下：

1、用一元运算符++，并且是前增量的方法，实现时钟的调快操作。例如要把时钟调快5秒，则执行5次” ++<对象> “ 的操作

2、用一元运算符–，并且是后增量的方法，实现时钟的调慢操作。例如要把时钟调慢10秒，则执行10次” <对象>-- “的操作

3、用构造函数的方法实现时钟对象的初始化，用输出函数实现时钟信息的输出

clock是系统内部函数，所以不要用来做类名或者其他

输入

第一行输入时钟的当前时间时、分、秒

第二行输入t表示有t个示例

第三行输入t个整数x，如果x为正整数，则表示执行调快操作，使用重载运算符++；如果x为负整数，则表示执行调慢操作，使用重载运算符–

每次的调快或调慢操作都是承接上一次调整后的结果进行，例如先调快10秒，再调慢2秒，那么调慢2秒是接着调快10秒后的结果进行的

输出

每行输出每个时钟调整操作后的时分秒

输入样例1

11 58 46
4
5 70 -22 -55

输出样例1

11:58:51
0:0:1
11:59:39
11:58:44

AC代码

#include<bits/stdc++.h>
using namespace std;

class Clock {
	int h, m, s;
public:
	Clock() {
		cin >> h >> m >> s;
	}

	Clock operator ++() {
		s++;
		if (s == 60) {
			s = 0;
			m++;
		}

		if (m == 60) {
			m = 0;
			h++;
		}

		if (h == 12) {
			h = 0;
		}
		return *this;
	}

	Clock operator --(int) {
		s--;
		if (s == -1) {
			s = 59;
			m--;
		}
		if (m == -1) {
			m = 59;
			h--;
		}
		if (h == -1)
			h = 11;
		return *this;
	}

	void print() {
		cout << h << ":" << m << ":" << s << endl;
	}
};

int main() {
	Clock c;
	int t;
	cin >> t;
	while (t--)
	{
		int n;
		cin >> n;
		if (n > 0) {
			while (n > 0){
				++c;
				n--;
			}
			c.print();
		}

		else {
			while (n < 0)
			{
				c--;
				n++;
			}
			c.print();
		}
	}
	return 0;
}