面向对象程序设计|运算符重载

news2024/11/24 17:56:24

题目一：分数的加减乘除（运算符重载）

题目描述：

Fraction类的基本形式如下：

要求如下：

1.实现Fraction类；common_divisor()和contracted()函数体可为空，不实现具体功能。

2.编写main函数，初始化两个Fraction对象的，计算它们之间的加减乘除。

输入要求：

第1行：依次输入第1个和第2个Fraction对象的分子和分母值。

输出要求：

每行依次分别输出加减乘除计算后的Fraction对象（直接输出分数值，不需要约简）。

输入样例：

1 3 2 5

输出样例：

fraction=11/15
fraction=-1/15
fraction=2/15
fraction=5/6

代码示例：

#include<iostream>
#include<iomanip>
#include<cstring>
#include<string> 
#include<cmath>
#include<algorithm>
using namespace std;

class Fraction {
private:
	int numerator, denominator;
	int common_divisor() {};
	int contracted() {};
public:
	Fraction(int x = 0, int y = 1) :numerator(x), denominator(y) {}
	Fraction(Fraction& fra)//拷贝构造函数
	{
		numerator = fra.numerator;
		denominator = fra.denominator;
	}
	Fraction operator + (Fraction& fra)//类内运算符重载：类名 + operator + 需要重载的运算符（类引用）
	{
		Fraction f;
		f.numerator = numerator * fra.denominator + fra.numerator * denominator;
		f.denominator = denominator * fra.denominator;
		return f;
	}
	Fraction operator - (Fraction& fra)
	{
		Fraction f;
		f.numerator = numerator * fra.denominator - fra.numerator * denominator;
		f.denominator = denominator * fra.denominator;
		return f;
	}
	Fraction operator * (Fraction& fra) {
		Fraction f;
		f.numerator = numerator * fra.numerator;
		f.denominator = denominator * fra.denominator;
		return f;
	}
	Fraction operator / (Fraction& fra)
	{
		Fraction f;
		f.numerator = numerator * fra.denominator;
		f.denominator = denominator * fra.numerator;
		return f;
	}
	void Set(int x, int y)
	{
		numerator = x;
		denominator = y;
	}
	void disp() {
		cout << "fraction=" << numerator << "/" << denominator << endl;
	}
};
int main()
{
	int a, b;
	cin >> a >> b;
	Fraction f1(a, b);
	cin >> a >> b;
	Fraction f2(a, b);
	Fraction f3;
	f3 = f1 + f2;
	f3.disp();
	f3 = f1 - f2;
	f3.disp();
	f3 = f1 * f2;
	f3.disp();
	f3 = f1 / f2;
	f3.disp();
	return 0;
}

题目二：四进制加法（运算符重载）

题目描述：

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

输入要求：

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

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

输出要求：

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

输入样例：

3
13
2
21

输出样例：

102

代码示例：

#include<iostream>
#include<iomanip>
#include<cstring>
#include<string> 
#include<cmath>
#include<algorithm>
using namespace std;


class Quaternary
{
private:
	int num;
public:
	Quaternary(int nn = 0) :num(nn) {}
	void Set(int nn)
	{
		num = nn;
	}
	Quaternary operator+(Quaternary& rhs)
	{
		int sum, a;
		int n = 0;
		int total = 0;
		sum = num + rhs.num;
		a = sum;
		while (a)//十进制转化成四进制的方法
		{
			a /= 10;
			n++;
		}
		for (int i = 0; i < n + 1; i++)
		{
			if (sum % 10 >= 4)
			{
				sum = (sum / 10 + 1) * 10 + sum % 10 - 4;
			}
			total += sum % 10 * pow(10, i);
			sum /= 10;
		}
		Quaternary qu(total);
		return qu;
	}
	void print() {
		cout << num << endl;
	}
};
int main() {
	int n, x;
	cin >> n;
	Quaternary* q;
	Quaternary qua;
	q = new Quaternary[n];
	for (int i = 0; i < n; i++)
	{
		cin >> x;
		q[i].Set(x);//动态内存分配的初始化
	}
	for (int i = 0; i < n; i++)
	{
		qua = qua + q[i];
	}
	qua.print();
}

注意四进制转化成十进制再转化为四进制的算法；

题目三：人民币输出（输入输出运算符重载）

题目描述：

定义一个人民币类，包括元、角、分三个非负整数属性，操作包括输入和输出

输入通过重载运算符>>实现，接收一个浮点数参数（精度为小数点后两位），并转化为元、角、分，例如输入1.23元，转为1元、2角、3分

输出通过重载运算符<<实现，对元角分进行输出，具体格式看示例

由于OJ编译器对double强制类型转换成int的处理精度有偏差，建议加0.005处理(例如数据1.38，由于误差，在内存中的存储值为1.379999）

输入要求：

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

第二行起，输入t个正浮点数，带两位小数，每个数值表示以元为单位的人民币金额

输出要求：

每行输出把浮点数的人民币金额，转化为元角分的整数格式，具体看输出

输入样例：

2
2.45
1.38

输出样例：

yuan=2 jiao=4 fen=5
yuan=1 jiao=3 fen=8

代码示例：

#include<iostream>
#include<iomanip>
#include<cstring>
#include<string> 
#include<cmath>
#include<algorithm>
using namespace std;

class RMB
{
private:
	float money;
	int yuan;
	int jiao;
	int fen;
public:
	RMB() {}
	friend istream& operator>>(istream& in, RMB& rhs);//输入输出流的运算符重载，记住格式
	friend ostream& operator<<(ostream& out, RMB& rhs);//friend ostream/istream & operator <</>> (ostream/istream & ,类引用)
};

istream& operator>>(istream& in, RMB& rhs)
{
	in >> rhs.money;//直接输入数据至类内
	rhs.yuan = (int)rhs.money;
	rhs.jiao = ((int)(rhs.money * 10)) % 10;
	rhs.fen = ((int)(rhs.money * 100)) % 10;
	return in;
}

ostream& operator<<(ostream& out, RMB& rhs)
{
	out << "yuan=" << rhs.yuan << " " << "jiao=" << rhs.jiao << " " << "fen=" << rhs.fen << endl;
	return out;
}

int main()
{
	int t;
	cin >> t;
	while (t--)
	{
		RMB rmb;
		cin >> rmb;
		cout << rmb;
	}
	return 0;
}

注意输入输出运算符重载的格式，记住就行了！

题目四：字符串比较（运算符重载）

题目描述：

定义一个字符串类str，用来存放不定长的字符串，重载运算符"= ="、"<"、">",用于两个字符窜的等于、小于和大于的比较运算。

要求如下：

1.实现str类；

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

输入要求：

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

输出要求：

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

输入样例：

i am a student
i love China
i love China

输出样例：

i love China
i am a student
i love China

代码示例：

#include<iostream>
#include<iomanip>
#include<cstring>
#include<string> 
#include<cmath>
#include<algorithm>
using namespace std;

class str
{
    char* p;
public:
    str() = default;//初始化构造
    str(const char* s)
    {
        p = new char[strlen(s) + 1];
        strcpy(p, s);//s串赋给p指针
    }

    friend bool operator > (str& lhs, str& rhs)//友元类型的运算符重载
    {
        return strcmp(lhs.p, rhs.p) > 0;
    }

    friend bool operator < (str& lhs, str&rhs)
    {
        return strcmp(lhs.p, rhs.p) < 0;
    }
    friend bool operator == (str& lhs, str& rhs)
    {
        return strcmp(lhs.p, rhs.p) == 0;
    }
    void show()
    {
        cout << p << endl;
    }
};

int main()
{
    string s1, s2, s3;

    getline(cin, s1);//输入带空格的字符串
    getline(cin, s2);
    getline(cin, s3);

    str A(s1.c_str()), B(s2.c_str()), C(s3.c_str());//c_str() 函数可以将 const string* 类型 转化为 const char* 类型

    if (A > B)
        A.show();
    else
        B.show();

    if (A < C)
        A.show();
    else
        C.show();

    if (B == C)
        B.show();
    else
        C.show();
    return 0;
}

注意友元函数运算符重载与类内运算符重载的区别，前者是（两个引用），后者是（一个引用）；以及c_str()函数的用法，注意加string头文件！！

题目五：矩形关系（运算符重载）

题目描述：

假设坐标采用二维平面坐标。

定义点类CPoint，包含属性x,y（整型）。方法有：带参构造函数，getX，getY分别返回点的x坐标，y坐标。

定义矩形类CRectangle，包含属性：矩形的左上角坐标leftPoint，右下角坐标rightPoint。类中方法有：

1）带参构造函数，初始化矩形的左上角、右下角

2）重载>运算符，参数为CPoint点对象，假设为p，若p在矩形内，返回true,否则返回false。

3）重载>运算符，第一个矩形若包含第二个矩形（部分边界可以相等），返回true，否则返回false。（要求该函数调用2）实现）

4）重载==运算符，判断两个矩形是否一致，返回true或false。

5）重载*运算符，判断两个矩形是否有重叠部分，返回true或false。

6）重载类型转换运算符，计算矩形的面积并返回，面积是整型。

7）重载<<运算符，输出矩形的两个角坐标和面积，具体格式见样例。

输入2个矩形，计算面积，判断矩形的关系。主函数如下，不可修改。

 可根据需要，添加构造函数和析构函数。

输入要求：

测试次数

每组测试数据如下：

矩形1的左上角、右下角坐标

矩形2的左上角、右下角坐标

输出要求：

每组测试数据输出如下，中间以空行分隔：

矩形1的坐标和面积（具体格式见样例）

矩形2的坐标和面积（具体格式见样例）

矩形1和矩形2的关系（矩形1包含矩形2、矩形2包含矩形1、矩形2和矩形1相等、矩形1和矩形2相交、矩形1和矩形2不相交）

输入样例：

2
1 4 4 1
2 3 3 2
1 4 4 1
0 3 5 2

输出样例：

矩形1:1 4 4 1 9
矩形2:2 3 3 2 1
矩形1包含矩形2

矩形1:1 4 4 1 9
矩形2:0 3 5 2 5
矩形1和矩形2相交

代码示例：

#include<iostream>
#include<iomanip>
#include<cstring>
#include<string> 
#include<cmath>
#include<algorithm>
using namespace std;

class Point
{
    int x, y;
public:
    Point(int xx, int yy) :x(xx), y(yy) {}
    int getX() { return x; }
    int getY() { return y; }
};

class Rectangle
{
private:
    Point leftPoint, rightPoint;
public:
    Rectangle(int xv1, int yv1, int xv2, int yv2) :leftPoint(xv1, yv1), rightPoint(xv2, yv2) {}
    bool operator > (Point& p)
    {
        if (p.getX() >= leftPoint.getX() && p.getX() <= rightPoint.getX() && p.getY() <= leftPoint.getY() && p.getY() >= rightPoint.getY())
        {
            return true;
        }
        else
        {
            return false;
        }
    }
    bool operator > (Rectangle& rhs)
    {
        if (*this > rhs.leftPoint && *this > rhs.rightPoint)//此处调用上一个运算符重载
        {
            return true;
        }
        else
        {
            return false;
        }
    }
    bool operator == (Rectangle& rhs)
    {
        if (this->rightPoint.getX() == rhs.rightPoint.getX() && this->leftPoint.getY() == rhs.leftPoint.getY() && this->rightPoint.getX() == rhs.rightPoint.getX() && this->rightPoint.getY() == rhs.rightPoint.getY())
        {
            return true;
        }
        else
        {
            return false;
        }
    }
    bool operator * (Rectangle& rhs)
    {
        if (rhs.leftPoint.getX() > rightPoint.getX() || rhs.leftPoint.getY() < rightPoint.getY() || rhs.rightPoint.getX() < leftPoint.getX() || rhs.rightPoint.getY() > leftPoint.getY())
        {
            return false;
        }
        else
        {
            return true;
        }
    }
    operator int()//int类型的运算符重载
    {
        int area = (rightPoint.getX() - leftPoint.getX()) * (leftPoint.getY() - rightPoint.getY());
        return area;
    }
    friend ostream& operator<<(ostream& out, Rectangle& rhs);
};

ostream& operator<<(ostream& out, Rectangle& rhs)
{
    out << rhs.leftPoint.getX() << " " << rhs.leftPoint.getY() << " " << rhs.rightPoint.getX() << " " << rhs.rightPoint.getY();
    return out;
}

int main()
{
    int t, x1, x2, y1, y2;
    cin >> t;
    while (t--)
    {
        cin >> x1 >> y1 >> x2 >> y2;
        Rectangle rect1(x1, y1, x2, y2);
        cin >> x1 >> y1 >> x2 >> y2;
        Rectangle rect2(x1, y1, x2, y2);

        cout << "矩形1:" << rect1 << " " << (int)rect1 << endl;
        cout << "矩形2:" << rect2 << " " << (int)rect2 << endl;

        if (rect1 == rect2)
        {
            cout << "矩形1和矩形2相等" << endl;
        }
        else if (rect2 > rect1)
        {
            cout << "矩形2包含矩形1" << endl;
        }
        else if (rect1 > rect2)
        {
            cout << "矩形1包含矩形2" << endl;
        }
        else if (rect1 * rect2)
        {
            cout << "矩形1和矩形2相交" << endl;
        }
        else
        {
            cout << "矩形1和矩形2不相交" << endl;
        }
        cout << endl;
    }
    return 0;
}

运算符重载一定要有返回值！！

题目六：矩阵（运算符重载）

题目描述：

下面主函数和Array类完成矩阵的输入、输出。请补齐Array类中需要的成员函数。

注意：主函数和CArray类已给代码不可修改，只可在CArray类中添加新的成员函数。修改已改代码不计分。

提示：根据已给代码分析CArray需要重载哪些运算符？

 

输入要求：

测试次数

每组测试数据格式如下：

正整数n、m，分表表示矩阵的行、列

n*m行整数数据

输出要求：

每组测试数据输出矩阵数据两次，具体输出格式见样例。

输入样例：

2
3 3
1 2 3
4 5 6
7 8 9
2 4
10 20 30 40
50 60 70 80

输出样例：

MatrixA:
1 2 3 
4 5 6 
7 8 9 
MatrixB:
1 2 3 
4 5 6 
7 8 9 
MatrixA:
10 20 30 40 
50 60 70 80 
MatrixB:
10 20 30 40 
50 60 70 80

代码示例：

#include<iostream>
#include<iomanip>
#include<cstring>
#include<string> 
#include<cmath>
#include<algorithm>
using namespace std;

class CArray
{
private:
    int n, m;
    int** data;
public:
    CArray() {}
    CArray(int nValue, int mValue) :n(nValue), m(mValue)
    {
        data = new int* [n];
        for (int i = 0; i < n; i++)
            data[i] = new int[m];
    }
    CArray(const CArray& a)
    {
        n = a.n;
        m = a.m;
        data = new int* [n];
        for (int i = 0; i < n; i++)
            data[i] = new int[m];
        for (int i = 0; i < n; ++i)
            for (int j = 0; j < m; j++)
                data[i][j] = a.data[i][j];
    }
    ~CArray()
    {
        for (int i = 0; i < n; i++)
            delete[]data[i];
        delete[]data;
    }
    CArray& operator = (const CArray& rhs)// = 运算符重载
    {
        n = rhs.n;
        m = rhs.m;
        data = new int* [n];
        for (int i = 0; i < n; i++)
            data[i] = new int[m];
        for (int i = 0; i < n; ++i)
            for (int j = 0; j < m; j++)
                data[i][j] = rhs.data[i][j];
        return *this;
    }
    int* operator [](const int x)//两个特殊的运算符重载
    {
        return data[x];
    }
    int operator () (int x, int y)
    {
        return data[x][y];
    }
};


int main()
{
    int t;
    int n, m;
    int i, j;
    cin >> t;
    while (t--)
    {
        cin >> n >> m;
        CArray matrixA(n, m);
        for (i = 0; i < n; ++i)
            for (j = 0; j < m; j++)
                cin >> matrixA[i][j];
        cout << "MatrixA:" << endl;
        for (i = 0; i < n; ++i)
        {
            for (j = 0; j < m; j++)
            {
                cout << matrixA(i, j) << " ";//重载()符号
            }
            cout << endl;
        }
        cout << "MatrixB:" << endl;
        CArray matrixB;
        matrixB = matrixA;
        for (i = 0; i < n; i++)
        {
            for (j = 0; j < m; j++)
            {
                cout << matrixB[i][j] << " ";//重载[]符号，本质是返回了一个指针
            }
            cout << endl;
        }
    }
    return 0;
}

特殊的运算符重载

题目七：X的放大与缩小（运算符重载）

题目描述：

X字母可以放大和缩小，变为n行X（n=1,3,5,7,9,...,21）。例如，3行x图案如下：

现假设一个n行（n>0，奇数）X图案，遥控器可以控制X图案的放大与缩小。遥控器有5个按键，1）show，显示当前X图案；2）show++, 显示当前X图案，再放大图案，n+2；3）++show，先放大图案，n+2，再显示图案；4）show--，显示当前X图案，再缩小图案，n-2；5）--show，先缩小图案，n-2，再显示图案。假设X图案的放大和缩小在1-21之间。n=1时，缩小不起作用，n=21时，放大不起作用。

用类CXGraph表示X图案及其放大、缩小、显示。主函数模拟遥控器，代码如下，不可修改。请补充CXGraph类的定义和实现。

输入要求：

第一行n，大于0的奇数，X图案的初始大小。

第二行，操作次数

每个操作一行，为show、show++、show--、--show、++show之一，具体操作含义见题目。

输出要求：

对每个操作，输出对应的X图案。

输入样例：

3
5
show
show++
show++
++show
--show

输出样例：

XXX
 X
XXX

XXX
 X
XXX

XXXXX
 XXX
  X
 XXX
XXXXX

XXXXXXXXX
 XXXXXXX
  XXXXX
   XXX
    X
   XXX
  XXXXX
 XXXXXXX
XXXXXXXXX

XXXXXXX
 XXXXX
  XXX
   X
  XXX
 XXXXX
XXXXXXX

代码示例：

#include<iostream>
#include<iomanip>
#include<cstring>
#include<string> 
#include<cmath>
#include<algorithm>
using namespace std;

class XGraph
{
private:
	int n;
public:
	XGraph(int nn) :n(nn) {}
	XGraph(XGraph& rhs)
	{
		n = rhs.n;
	}
	XGraph& operator++()//前置++，返回的是引用；前置用引用则是为了不产生临时变量，可以减少内存的消耗。
	{
		if (this->n <= 19)
		{
			this->n += 2;
		}
		return *this;
	}
	XGraph operator++(int)//后置++，返回的是临时对象，因为后置的时候原来的对象已经被++改变了。
	{					  //后置的函数的声明里面参数列表中比前置多了一个int，这里的int其实是作为区分前后置的标志，在函数体里面并没有直接地用到。
		XGraph temp = *this;
		if (this->n <= 19)
		{
			this->n += 2;
		}
		return temp;
	}
	XGraph& operator--()//原理与++或--相同
	{
		if (this->n >= 3)
		{
			this->n -= 2;
		}
		return *this;
	}
	XGraph operator--(int)
	{
		XGraph temp = *this;
		if (this->n >= 3)
		{
			this->n -= 2;
		}
		return temp;
	}
	friend ostream& operator<<(ostream& out, const XGraph& rhs);//输出运算符重载，记住特定的格式
};

ostream& operator<<(ostream& out, const XGraph& rhs)
{
	for (int i = 0; i < (rhs.n + 1) / 2; i++)
	{
		for (int j = 0; j < i; j++)
		{
			cout << " ";
		}
		for (int j = i; j < rhs.n - i; j++)
		{
			cout << "X";
		}
		cout << endl;
	}
	for (int i = (rhs.n + 1) / 2; i < rhs.n; i++)
	{
		for (int j = rhs.n - 1 - i; j > 0; j--)
		{
			cout << " ";
		}
		for (int j = rhs.n - 1 - i; j <= i; j++)
		{
			cout << "X";
		}
		cout << endl;
	}
	return out;
}


int main()
{
	int t, n;
	string command;
	cin >> n;
	XGraph xGraph(n);
	cin >> t;
	while (t--)
	{
		cin >> command;
		if (command == "show++")
		{
			cout << xGraph++ << endl;
		}
		else if (command == "++show")
		{
			cout << ++xGraph << endl;
		}
		else if (command == "show--")
		{
			cout << xGraph-- << endl;
		}
		else if (command == "--show")
		{
			cout << --xGraph << endl;
		}
		else if (command == "show")
			cout << xGraph << endl;

	}
	return 0;
}

注意区分前++ / --和后++ / -- 的区别，前置返回引用，后置返回临时对象！

题目八：集合（运算符重载）

题目描述：

集合是由一个或多个确定的元素所构成的整体。集合的运算有并、交、相对补等。

集合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 100

输出样例：

A: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 3

A: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>
#include<iomanip>
#include<cstring>
#include<string> 
#include<cmath>
#include<algorithm>
using namespace std;

class Set
{
private:
	int n;
	int* data;
public:
	Set(int nn, int* arr) :n(nn)
	{
		data = new int[n];
		for (int i = 0; i < n; i++)
		{
			data[i] = arr[i];
		}
	}
	Set(Set& rhs) :n(rhs.n)
	{
		for (int i = 0; i < n; i++)
		{
			data[i] = rhs.data[i];
		}
	}
	~Set()
	{
		delete[]data;
	}
	Set operator + (const Set& rhs)
	{
		int count = 0;
		int mark[100] = { 0 };
		for (int i = 0; i < this->n; i++)
		{
			for (int j = 0; j < rhs.n; j++)
			{
				if (this->data[i] == rhs.data[j])
				{
					count++;
					mark[j] = 1;
				}
			}
		}
		int c = this->n + rhs.n - count;
		int* crr = new int[c];
		for (int i = 0; i < this->n; i++)
		{
			crr[i] = this->data[i];
		}
		int cnt = 0;
		for (int i = this->n; i < c; i++)
		{
			while (1)
			{
				if (mark[cnt] == 0)
				{
					crr[i] = rhs.data[cnt];
					cnt++;
					break;
				}
				else
				{
					cnt++;
				}
			}
		}
		Set C(c, crr);
		return C;
	}
	Set operator - (const Set& rhs)
	{
		int count = 0;
		int mark[100] = { 0 };
		for (int i = 0; i < this->n; i++)
		{
			for (int j = 0; j < rhs.n; j++)
			{
				if (this->data[i] == rhs.data[j])
				{
					count++;
					mark[i] = 1;
				}
			}
		}
		int c = this->n - count;
		int* crr = new int[c];
		int cnt = 0;
		for (int i = 0; i < c; i++)
		{
			while (1)
			{
				if (mark[cnt] == 0)
				{
					crr[i] = this->data[cnt];
					cnt++;
					break;
				}
				else
				{
					cnt++;
				}
			}
		}
		Set C(c, crr);
		return C;
	}
	Set operator * (const Set& rhs)
	{
		int count = 0;
		int mark[100] = { 0 };
		for (int i = 0; i < this->n; i++)
		{
			for (int j = 0; j < rhs.n; j++)
			{
				if (this->data[i] == rhs.data[j])
				{
					count++;
					mark[i] = 1;
				}
			}
		}
		int c = count;
		int* crr = new int[c];
		int cnt = 0;
		for (int i = 0; i < c; i++)
		{
			while (1)
			{
				if (mark[cnt] == 1)
				{
					crr[i] = this->data[cnt];
					cnt++;
					break;
				}
				else
				{
					cnt++;
				}
			}
		}
		Set C(c, crr);
		return C;
	}
	friend ostream& operator<<(ostream& out, const Set& rhs);
};

ostream& operator<<(ostream& out, const Set& rhs)
{
	for (int i = 0; i < rhs.n; i++)
	{
		cout << rhs.data[i];
		if (i != rhs.n - 1)
		{
			cout << " ";
		}
		else
		{
			cout << endl;
		}
	}
	return out;
}


int main()
{
	int t;
	cin >> t;
	while (t--)
	{
		int a;
		cin >> a;
		int* arr = new int[a];
		for (int i = 0; i < a; i++)
		{
			cin >> arr[i];
		}
		Set A(a, arr);
		int b;
		cin >> b;
		int* brr = new int[b];
		for (int i = 0; i < b; i++)
		{
			cin >> brr[i];
		}
		Set B(b, brr);

		cout << "A:" << A;
		cout << "B:" << B;

		cout << "A+B:" << A + B;
		cout << "A*B:" << A * B;
		cout << "(A-B)+(B-A):" << (A - B) + (B - A);
		cout << endl;
	}
	return 0;
}

问题考察的运算符重载不难，但是算法较麻烦！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/668289.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

Qt QPainterPath

Qt QPainterPath

作用 为painter设置好绘画路径 成员函数 painter.drawPath() 1,使用当前笔画轮廓; 2,填充path指定的路径绘画出来的图形。 xxx.to() lineTo() moveTo() 使用path作画&#xff0c;一定要先将path的启动移动到需要开始绘画的点&#xff0c;否则默认从 &#xff08;0&…
阅读更多...
【大数据之Hive】十三、Hive-HQL函数之单行函数和高级聚合函数

【大数据之Hive】十三、Hive-HQL函数之单行函数和高级聚合函数

Hive内置函数&#xff1a;单行函数、聚合函数、炸裂函数、窗口函数。 --查看系统内置函数&#xff1a; show functions;--查看内置函数用法&#xff1a; desc function 函数名;--查看内置函数详细信息&#xff1a; desc function extended 函数名&#xff1b;一、单行函数 单行…
阅读更多...
GDB调试大全

GDB调试大全

嵌入式开发必备工具&#xff01;&#xff01;&#xff01;学就完事了&#xff01;&#xff01;&#xff01; 目录 GDB初使用 准备条件&#xff1a;Makefile&#xff0c;section1.cpp 初步使用命令 启动调试 启动调试别传入参数 附加到进程 逐过程执行 逐语句执行 退出函…
阅读更多...
apm装机教程（二）：四旋翼

apm装机教程（二）：四旋翼

文章目录 前言一、接线二、刷固件三、设置机架四、校准遥控器五、设置遥控开关六、校准传感器七、设置参数 前言 硬件&#xff1a; pix2.4.8 250穿越机 云卓T10遥控 软件&#xff1a; APM4.3.7 QGC MP 一、接线 GPS接gps和i2c口&#xff0c;接收机的p/s口接飞控RCIN 二、刷…
阅读更多...
SAP从入门到放弃系列之BOM行项目类别-R类别-Part3

SAP从入门到放弃系列之BOM行项目类别-R类别-Part3

文章目录 一、BOM行项目类别设置二、BOM主数据维护三、参数详解3.1、尺寸大小3.2、尺寸大小单位3.3、公式3.4、所需数量3.5、可变尺寸数量3.6、可变尺寸数量单位 四、测试示例演示&#xff1a;小结 一、BOM行项目类别设置 创建或者更改BOM时&#xff0c;BOM行项目类别选择R&am…
阅读更多...
SSM超市库存商品管理系统+jsp【附万字文档(Lun文)】

SSM超市库存商品管理系统+jsp【附万字文档(Lun文)】

主要功能 管理员权限登录&#xff1a; ①主页、个人中心&#xff1a;修改密码、个人信息 ②员工管理&#xff1a;可以根据员工姓名、手机号、身份证查询&#xff0c;以及增删改查操作 ③会员管理&#xff1a;可以根据会员姓名、手机号、身份证查询&#xff0c;以及增删改查操作…
阅读更多...
【进阶]Java：线程通信（了解）

【进阶]Java：线程通信（了解）

什么是线程通信&#xff1f; 当多个线程共同操作共享的资源时&#xff0c;线程间通过某种方式互相告知自己的状态&#xff0c;以相互协调&#xff0c;并避免无效的资源争夺。 线程通信的常见模型&#xff08;生产者与消费者模型&#xff09; 生产者线程负责生产数据消费者线…
阅读更多...
IDE/VS2017社区版安装+Qt部署+旧项目迁移

IDE/VS2017社区版安装+Qt部署+旧项目迁移

文章目录 概述安装包获取卸载旧版本安装过程首次使用Qt插件配置和使用插件配置Qt项目创建向导 VS2015项目迁移到VS2017 概述 这几天想开始使用glog这个开源日志库&#xff0c;发现其已经在很大程度上使用C14标准了&#xff0c;而VS2015并不能完全支持该标准。根据一些教程试图…
阅读更多...
Java的Set接口及其实现类(面试题)

Java的Set接口及其实现类(面试题)

Set接口中没有额外定义新的方法&#xff0c;使用的都是Collection接口中声明过的方法。 * 1. Set接口的框架&#xff1a;** |----Collection接口&#xff1a;单列集合&#xff0c;用来存储一个一个的对象* |----Set接口&#xff1a;存储无序的、不可重复的数据 --&g…
阅读更多...
【Spring】— 应用案例——基于注解的Spring MVC应用

【Spring】— 应用案例——基于注解的Spring MVC应用

目录 应用案例——基于注解的Spring MVC应用1.搭建项目环境2.修改配置文件3.修改Controller类4.启动项目&#xff0c;测试应用 应用案例——基于注解的Spring MVC应用 为了帮助读者熟悉掌握Spring MVC的核心类和注解的使用&#xff0c;接下来将以注解的方式对入门案例进行改写…
阅读更多...
CPU多核一定比单核性能强吗

CPU多核一定比单核性能强吗

在一般人的眼中&#xff0c;多核性能肯定比单核强&#xff0c;处理器核心越多越好&#xff0c;但果真如此吗&#xff1f; 许多人认为CPU 内核越多越好。然而&#xff0c;情况并非总是如此。这就是为什么更多内核并非在所有情况下都是好的选择&#xff0c;这不仅仅是因为在芯片…
阅读更多...
数据结构——单向链表(万字讲解）

数据结构——单向链表(万字讲解）

单向链表&#xff08;又名单链表、线性链表&#xff09;是链表的一种&#xff0c;其特点是链表的链接方向是单向的&#xff0c;对链表的访问要通过从头部开始&#xff0c;依序往下读取。 //单链表的打印 void SLTPrint(SLTNode* phead) {SLTNode* cur phead;while (cur){pri…
阅读更多...
数据孤岛如何形成，企业如何破解？

数据孤岛如何形成，企业如何破解？

国内企业数据化现状 在数字化时代&#xff0c;数据已经成为了企业不可或缺的重要资产。企业内部部门或系统之间存在着数据割裂现象&#xff0c;导致数据无法流通和共享&#xff0c;从而形成数据孤岛的现象。对于企业来说&#xff0c;数据孤岛问题是十分普遍的&#xff0c;它阻…
阅读更多...
如何在项目管理中获得更多权威和影响力？这篇文章告诉你！

如何在项目管理中获得更多权威和影响力？这篇文章告诉你！

1 透明力 信息力和感知力是对环境的观察、观察、再观察&#xff0c;这些 观察的结果只有透明出来&#xff0c;才能发挥效用。你要想法把你看到的问题可视化&#xff0c;让决策者和团队都能看到问题。即透明的力量。 1.1 怎么运用透明的力量呢&#xff1f; 我曾在某团队经常听…
阅读更多...
win11 系统安装 wsl

win11 系统安装 wsl

1. 打开虚拟设置 在【开始】搜索【启用或关闭 Windows 功能】&#xff0c;打开Windows 功能对话框&#xff0c;勾选“适用于Linux的Windows子系统”和“虚拟机平台”两个选项。 2. wsl 安装 管理员模式启动powershell 设置wsl版本&#xff1a;wsl --set-default-version 1 更新…
阅读更多...
业务 IT 一体化：华为云 SaaS Package 做到了

业务 IT 一体化：华为云 SaaS Package 做到了

SaaS 这个概念在近两年可谓十分火热&#xff0c;特别是进入到了后疫情时代&#xff0c;似乎离不开 SasS。然而很多人并没有真正理解 SaaS 的概念&#xff0c;对 SaaS 的认知还是比较片面。 你要弄清 SaaS&#xff0c;首先就绕不开 laaS 和 PaaS。下面这张图可以很直观地让你明…
阅读更多...
leetcode40. 组合总和 II (java-回溯算法)

leetcode40. 组合总和 II (java-回溯算法)

组合总和 II leetcode40. 组合总和 II题目描述解题思路代码演示 回溯算法专题 leetcode40. 组合总和 II 来源&#xff1a;力扣&#xff08;LeetCode&#xff09; 链接&#xff1a;https://leetcode.cn/problems/combination-sum-ii 题目描述 给定一个候选人编号的集合 candida…
阅读更多...
【滤波】扩展卡尔曼滤波器

【滤波】扩展卡尔曼滤波器

本文主要翻译自rlabbe/Kalman-and-Bayesian-Filters-in-Python的第11章节11-Extended-Kalman-Filters&#xff08;扩展卡尔曼滤波&#xff09;。 %matplotlib inline#format the book import book_format book_format.set_style()我们发展了线性卡尔曼滤波器的理论。然后在上两…
阅读更多...
Fiddler之日常使用简介

Fiddler之日常使用简介

目录 前言&#xff1a; Fiddler界面简介 一、Fiddler抓取http、https请求配置 二、抓取指定域名会话 三、http请求统计试图 前言&#xff1a; Fiddler是一款功能强大的Web调试工具&#xff0c;它可以帮助开发人员在开发和测试过程中捕获、修改和检查HTTP请求和响应。 使用Fiddl…
阅读更多...
Python基础（11）——Python循环（while、for）

Python基础（11）——Python循环（while、for）

Python基础&#xff08;11&#xff09;——Python循环&#xff08;while、for&#xff09; 文章目录 Python基础&#xff08;11&#xff09;——Python循环&#xff08;while、for&#xff09;目标一. 循环简介1.1 循环的作用1.2 循环的分类 二. while的语法2.1 快速体验 三. w…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023