-
A. 日期比较（运算符重载之类型转换）
定义一个日期类CDate，包含属性：年、月、日，都是整数。
构造函数含单个参数，参数是八位整数，默认值为0，实现整数转为日期类型，例如参数为20170612，转为year = 2017, month = 6, day = 12
实现转换运算符重载，把日期类型转为整数，例如2017年6月8日转为20170608。注意，如果月或日小于10，转化为整数时要补0
实现日期的输出函数print，具体格式看示范数据
主函数如下，不能修改，请实现上面的日期类
int main() { int t, t1, t2; CDate c1, c2; cin >> t; while (t--) { cin >> t1 >> t2; c1 = t1; c2 = t2; ((c1 > c2) ? c1 : c2).print(); //日期大的输出，在代码c1 > c2中，会自动把c1和c2转换为整数进行比较 } return 0; }注意：本题目不需要也不要重载>运算符，只要实现转换运算符重载，能够把日期类型转为整数就可以了
输入
第一行输入t表示有t对日期
接着每两行输入两个日期
输入t对
输出
每行输出一对日期中，日期大的信息
#include <iostream>
#include <iomanip>
using namespace std;
class CDate
{
private:
int year, month, day;
public:
CDate(){}
CDate(int r)
{
year = r / 10000; month = r / 100 % 100; day = r % 100;
}
operator int() //进行强制类型转化，重载时必须为类的成员函数
{
int num = year * 10000 + month * 100 + day; //将日期转换为int类型
return num;
}
void print()
{
cout << year << "年" << setw(2) << setfill('0') << month << "月" << setw(2) << setfill('0') << day << "日" << endl;
}
};
int main()
{
int t, t1, t2;
CDate c1, c2;
cin >> t;
while (t--)
{
cin >> t1 >> t2;
c1 = t1;
c2 = t2;
((c1 > c2) ? c1 : c2).print(); //日期大的输出，在代码c1 > c2中，会自动把c1和c2转换为整数进行比较
}
return 0;
}-
B. OOP一元多项式类（运算符重载）
一元多项式按照升幂表示为：
Pn(x) = p0+ p1x + p2x2+ … +pnxn。(n>=0)
构建一元多项式类保存多项式中每项的系数和指数。并重载输入输出运算符，完成多项式的输入以及输出；重载加法，减法，乘法运算符，完成多项式的运算。
输入
测试数据数
对于每组测试数据
第一行，第一个多项式：多项式项数n 系数1 指数1 系数2 指数2 ...... 系数n 指数n
第二行，第二个多项式：多项式项数n 系数1 指数1 系数2 指数2 ......系数n 指数n
数据保证输入数据中多项式均为升幂且所有数据都为整数
输出
每组测试数据输出三行，分别是两个多项式的加、减、乘。
2
3 -9 0 4 1 -3 5
1 -7 0
2 1 0 -1 3
3 1 0 1 1 -1 2-16+4x-3x^5
-2+4x-3x^5
63-28x+21x^5
2+x-x^2-x^3
-x+x^2-x^3
1+x-x^2-x^3-x^4+x^5
#include<iostream>
#include<iomanip>
using namespace std;
class oop {
int a[50];//指数
int b[50];//系数
public:
oop() {
}
oop(int* x, int* y) {
int i;
for (i = 0; i < 50; i++) //对指数赋值
{
a[i] = x[i];
}
for (i = 0; i < 50; i++) //对系数赋值
{
b[i] = y[i];
}
}
oop(const oop& m) //拷贝构造函数
{
int i;
for (i = 0; i < 50; i++)
{
a[i] = m.a[i];
b[i] = m.b[i];
}
}
oop operator +(oop& m) //多项式加法运算
{
int i;
for (i = 0; i < 50; i++) //循环遍历当对方的项的系数不为零时，即存在该项，则此时将对方系数加到我方
{
if (m.b[i] != 0) { //指数不用操作是因为下标对应上了，最后只需要输出指数数组对应的下标就可以了
b[i] += m.b[i];
}
}
return *this; //返回我方多项式
}
oop operator -(oop& m) //多项式减法运算
{
int i;
for (i = 0; i < 50; i++) //循环遍历当对方的项的系数不为零时，即存在该项，则此时将我方系数减去对方系数
{
if (m.b[i] != 0) {
b[i] -= m.b[i];
}
}
return *this; //返回我方多项式
}
oop operator *(oop& m)
{
int i, j, k;
int x[50], y[50]; //x为指数、y为系数
for (i = 0; i < 50; i++)
{
x[i] = i; y[i] = 0;
}
for (i = 0; i < 50; i++) //乘法运算时，运用分配律，则嵌套循环，当我方项系数不为零时，开始相乘，寻找对方的系数不为零的项
{
if (b[i] != 0)
{
for (j = 0; j < 50; j++)
{
if (m.b[j] != 0)
{
y[i + j] += b[i] * m.b[j]; //乘法运算时，指数进行相加，系数进行相乘，则下标i+j对应的就是指数的相加，y存储的即为系数
}
}
}
}
for (i = 0; i < 50; i++) //需要返回oop类型
{
b[i] = y[i];
}
return *this;
}
void print()
{
int i,flag = 0;
for (i = 0; i < 50; i++)
{
if (b[i] == 0)flag++; //统计多项式里不存在的项
}
if (flag== 50)cout << "0" << endl; //系数全为零即该多项式也为零
else {
flag = 0; //重新赋值为0
if (b[0] != 0) { //如果多项式第一项不为零，则输出，flag用来判断后面项是否成为第一项，不是则需要在前面添加正负号
cout << b[0];
flag=1;
}
if (b[1] != 0) //如果指数为1的系数不为零，即存在，由于指数1不需要^，所以需另外判断
{
if (flag != 0) {
if (b[1] == 1)cout << "+" << "x"; //由于为1或者-1时的系数1不显示，则需要另外判断
else if (b[1] == -1)cout << "-" << "x";
else if (b[1] > 0)cout << "+" << b[1] << "x";
else if (b[1] < 0)cout << b[1] << "x";
}
else
{
if (b[1] == 1)cout << "x"; //由于为1或者-1时的系数1不显示，则需要另外判断
else if (b[1] == -1)cout << "-" << "x";
else if (b[1] > 0)cout << b[1] << "x";
else if (b[1] < 0)cout << b[1] << "x";
}
flag=1;
}
for (i = 2; i < 50; i++)
{
if (b[i] != 0)
{
if (b[i] == 1) {
if (flag == 0)cout << "x^" << a[i];
else cout << "+" << "x^" << a[i];
}
else if (b[i] == -1)cout << "-" << "x^" << a[i];
else if (b[i] > 0) {
if (flag == 0)cout << b[i] << "x^" << a[i];
else cout << "+" << b[i] << "x^" << a[i];
}
else if (b[i] < 0)cout << b[i] << "x^" << a[i];
flag=1;
}
}
cout << endl;
}
}
};
int main()
{
int x1[50], y1[50], x2[50], y2[50]; //x1、x1为指数，y1、y2为系数
int i, j, t, n;
int a, b;
cin >> t;
while (t--)
{
for (i = 0; i < 50; i++) //对指数每一位按多项式里项的顺序赋值为i，对系数每一位赋值为0，方便后面运算时判断
{
x1[i] = i;
y1[i] = 0;
x2[i] = i;
y2[i] = 0;
}
cin >> n;
for (i = 0; i < n; i++) //a为系数，b为指数
{
cin >> a >> b;
for (j = 0; j < 50; j++) //当输入的指数与一开始x1赋值的指数0-49一致时，将输入的系数加在y1的系数上，相互对应
{
if (b == x1[j])
{
y1[j] += a;
break;
}
}
}
oop p1(x1, y1); //一对里的第一个多项式
cin >> n;
for (i = 0; i < n; i++)
{
cin >> a >> b;
for (j = 0; j < 50; j++) //当输入的指数与一开始x2赋值的指数0-49一致时，将输入的系数加在y2的系数上，相互对应
{
if (b == x2[j])
{
y2[j] += a;
break;
}
}
}
oop p2(x2, y2); //一对里的第二个多项式
oop p3, p4;
p3 = p1;
p4 = p1;
p1 + p2; //加法
p1.print();
p3 - p2; //减法
p3.print();
p2* p4; //乘法
p2.print();
}
return 0;
}C. 三维坐标点的平移（运算符重载）
定义一个三维点Point类，利用友元函数重载"++"和"--"运算符，并区分这两种运算符的前置和后置运算。
要求如下：
1.实现Point类；
2.编写main函数，初始化1个Point对象，将这个对象++或--后赋给另外一个对象，并输出计算后对象的坐标信息。
输入
第1行：输入三个int类型的值，分别为一个Point对象p1的x,y,z坐标。
输出
第1行：Point对象p1后置++之后的坐标信息输出。
第2行：Point对象p1后置++操作后赋给另外一个Point对象p2的坐标信息。
第3行开始，依次输出前置++，后置--，前置--运算的坐标信息，输出格式与后置++一样。
10 20 30
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=291
#include <iostream>
using namespace std;
class point
{
private:
int x, y, z;
public:
point(int xx = 0, int yy = 0, int zz = 0)
{
x = xx; y = yy; z = zz;
}
void set(int xx, int yy, int zz)
{
x = xx; y = yy; z = zz;
}
friend point operator ++(point& a);
friend point operator ++(point& ,int);
friend point operator --(point& );
friend point operator --(point& ,int);
void show()
{
cout << "x=" << x << " " << "y=" << y << " " << "z=" << z << endl;
}
};
point operator ++(point& a)//前置++ 加完再使用
{
a.x++; a.y++; a.z++;
return a;
}
point operator ++(point& a,int)//后置++ 先使用后加加
{
point temp(a);
a.x++; a.y++; a.z++;
return temp;
}
point operator --(point& a)//前置-- 先减后使用
{
a.x--; a.y--; a.z--;
return a;
}
point operator --(point& a,int)//后置-- 先使用后减减
{
point temp(a);
a.x--; a.y--;a.z--;
return temp;
}
int main()
{
int xx, yy, zz;
cin >> xx >> yy >> zz;
point p1(xx, yy, zz);
point p2;
p1++;
p1.show();
p1.set(xx, yy, zz);
p2 = p1++;
p2.show();
p1.set(xx, yy, zz);
p2 = ++p1;
p1.show(); p2.show();
p1.set(xx, yy, zz);
p2 = p1--;
p1.show(); p2.show();
p1.set(xx, yy, zz);
p2 = --p1;
p1.show(); p2.show();
return 0;
}D. 集合（运算符重载）
集合是由一个或多个确定的元素所构成的整体。集合的运算有并、交、相对补等。
集合A和集合B的交集：由属于A且属于B的相同元素组成的集合。
集合A和集合B的并集：由所有属于集合A或属于集合B的元素所组成的集合。
集合B关于集合A的相对补集，记做A-B：由属于A而不属于B的元素组成的集合。
假设集合A={10，20，30}，集合B={1，10，50，8}。则A与B的并是{10，20，30,1,50,8}，A与B的交是{10}，B关于A的相对补集是{20,30}。
定义整数集合类CSet，属性包括：集合中的元素个数n，整型指针data存储集合中的元素。
方法有：重载输出，按样例格式输出集合中的元素。
重载+运算符，求集合A和集合B的并集，并返回结果集合。
重载-运算符，求集合B关于集合A的相对补集，并返回结果集合。
重载*运算符，求集合A和集合B的交集，并返回结果集合。
主函数输入集合A、B的数据，计算集合的并、交、相对补。
可根据题目，为CSet类添加需要的成员函数。
输入
测试次数
每组测试数据两行，格式如下：
第一行：集合A的元素个数和元素
第二行：集合B的元素个数和元素
输出
每组测试数据输出如下：
第一行：集合A
第二行：集合B
第三行：A和B的并
第四行：A和B的交
第五行：B关于A的相对补集 与 A关于B的相对补集的并，即(A-B)+(B-A)
每组测试数据间以空行分隔。
2
3 10 20 30
4 10 1 2 3
5 100 2 3 4 -10
6 -34 12 2 4 90 100A:10 20 30
B:10 1 2 3
A+B:10 20 30 1 2 3
A*B:10
(A-B)+(B-A):20 30 1 2 3A:100 2 3 4 -10
B:-34 12 2 4 90 100
A+B:100 2 3 4 -10 -34 12 90
A*B:100 2 4
(A-B)+(B-A):3 -10 -34 12 90
#include <iostream>
using namespace std;
class CSet
{
private:
int n;
int* data;
public:
CSet(){
data = new int[50];
}
CSet(int n1, int* p)
{
n = n1;
data = new int[n];
int j;
for (j = 0; j < n; j++)
data[j] = p[j];
}
CSet operator * (CSet& b) //交集
{
CSet c;
int j, i,k=0;
for (i = 0; i < n; i++)
{
for (j = 0; j < b.n; j++)
{
if (data[i] == b.data[j])
{
c.data[k] = data[i]; //把两个集合中相同的元素赋值给结果集合
k++;
break;
}
}
}
c.n = k; //结果集合的元素个数
return c;
}
CSet operator + (CSet& b) //并集
{
CSet c;
int i, j;
int k = n + b.n; //初始结果集合元素个数为两个集合的元素个数之和
c.n = k;
for (i = 0; i < n; i++) //分别将两个集合的元素逐个赋值给结果集合
{
c.data[i] = data[i];
}
for (i = 0; i < b.n; i++)
{
c.data[n + i] = b.data[i];
}
cout << " 22 " << c.data[k] << endl;
for (i = 0; i < n; i++) //判断结果集合中有无出现多次的元素，若存在，则将后面的元素逐一移到前面
{
for (j = n; j < k; j++)
{
if (i != j)
{
if (c.data[i] == c.data[j])
{
c.n--; //有相同的元素时，结果集合的元素个数减1
for (int q = j; q < k; q++)
{
c.data[q] = c.data[q + 1]; //元素往前移
}
}
}
}
}
return c;
}
CSet operator - (CSet& b)
{
CSet c;
int i, j;
int k = 0;
for (i = 0; i < n; i++)
{
for (j = 0; j < b.n; j++)
{
if (data[i] == b.data[j])
break;
if (j == b.n - 1)
{
c.data[k] = data[i];
k++;
}
}
}
c.n = k;
return c;
}
void show()
{
cout << data[0];
for (int i = 1; i < n; i++)
cout <<" "<<data[i];
cout << endl;
}
};
int main()
{
int t,n;
int d[20];
cin >> t;
while (t--)
{
cin >> n; //集合A多少个元素个数
for (int i = 0; i < n; i++)
{
cin >> d[i];
}
CSet c1(n, d);
cin >> n; //集合B多少个元素个数
for (int i = 0; i < n; i++)
{
cin >> d[i];
}
CSet c2(n, d);
CSet c3;
CSet c4;
CSet c5;
cout << "A:";
c1.show();
cout << "B:";
c2.show();
c3 = c1 + c2;
cout << "A+B:";
c3.show();
c3 = c1 * c2;
cout << "A*B:";
c3.show();
c3 = (c1 - c2);
c4=(c2 - c1);
c5 = c3 + c4;
cout << "(A-B)+(B-A):";
c5.show();
cout << endl;
}
return 0;
}E. 四进制加法（运算符重载）
定义一个四进制的类，重定义“+”号实现四进制数的累加。
输入
第一行输入所需要的四进制数的个数
第二行开始，依次输入四进制数
输出
所有输入四进制数累加的和
3
13
2
21102
#include <iostream>
#include <math.h>
using namespace std;
class four
{
private:
int num;
public:
four() { num = 0; }
four(int n)
{
num = n;
}
void set(int n)
{
num = n;
}
four operator+(four& f)
{
int s1, a, len = 0, s2 = 0;
s1 = num + f.num; //
a = s1;
while (a)
{
a = a / 10;
len++; //计算出相加后的长度
}
for(int i=0;i<len+1;i++)
{
while (s1 % 10 >= 4)//四进制只有0，1，2，3表示
{
s1 = (s1 / 10 + 1) * 10 + s1 % 10 - 4;//比如让15 变成21：不满足的位的前一位加一，
}
s2 += s1 % 10 * pow(10, i);
s1 /= 10;
}
four temp(s2);
return temp;
}
void print()
{
cout << num << endl;
}
};
int main()
{
int t,x;
cin >> t;
four f[10];
for (int i = 0; i < t; i++)
{
cin >> x;
f[i].set(x);
}
four ff;
for (int i = 0; i < t; i++)
{
ff = ff + f[i];
}
ff.print();
return 0;
}
822
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
