实验十二 运算符重载

A.三维坐标点的平移（递增++ 递增--的重载）

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

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

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

输出

原值是最初输入的数值

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

第2行是p1恢复原值，接着p1后置++同时复制给p2，p2输出
第3、4行是p1恢复原值，p1前置++同时输出，然后p1再输出
第5、6行是p1恢复原值，p1后置–后，再输出，接着输出一次原值
第7、8行是p1恢复原值，p1前置–同时输出，然后p1再输出

输入样例
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=29

#include<iostream>
using namespace std;
 
class point
{
    int x,y,z;
public:
    point(int xx = 0, int yy = 0, int zz = 0)
    {
        x = xx; y = yy; z = zz;
    }
    friend point operator ++(point&p); //全局函数
    friend point operator ++(point&p, int);
    friend point operator --(point&p);
    friend point operator --(point&p, int);  
    void show()const
    {
        cout << "x=" << x << " y=" << y << " z=" << z << endl;
    }
};
 
point operator ++(point& p)//对于前增量，我们直接让它++或--完了之后返回就可以了。
{
    p.x++; p.y++; p.z++;
    return p;
}
point operator ++(point& p, int)//对于后增量，我们应该要创建一个临时变量先存储现值，然后做++或--，返回临时变量的值。
{                               //int 占位区分
    point temp=p;
    p.x++; p.y++; p.z++;
    return temp;
}
point operator --(point& p)
{
    p.x--; p.y--; p.z--;
    return p;
}
point operator --(point& p, int)
{
    point temp=p;
    p.x--; p.y--; p.z--;
    return temp;
}
int main()
{
    int x, y, z;
    cin >> x >> y >> z;
    point p1(x, y, z);
    point p2;
    point p3 = p1;//p1原值   类对象之间的赋值也可以通过赋值运算符“=”进行。
   
    p1++;
    p1.show();//p1后置++后，再输出
   
    p1 = p3; //p1恢复原值
    p2 = p1++;//p1后置++同时复值给p2
    p2.show();//p2输出
 
    p1 = p3; //p1恢复原值
    (++p1).show();//p1前置++同时输出
    p1.show(); //然后p1再输出
 
    p1 = p3;//p1恢复原值
    p1--;
    p1.show(); //p1后置–-后，再输出
    p1 = p3;
    p1.show();// 接着输出一次原值
 
    p1 = p3; //p1恢复原值
    (--p1).show();//p1前置–同时输出
    p1.show();//然后p1再输出
}
 

B. 分数的加减乘除（加减乘除重载 局部函数）

Fraction类的基本形式如下：

// 定义Fraction类
class Fraction
{
private:
    int fz, fm;
    int commonDivisor(); // 计算最大公约数
    void contracted(); // 分数化简
public:
    Fraction(int = 0, int = 1);
    Fraction(Fraction&);
    Fraction operator+(Fraction);
    Fraction operator-(Fraction);
    Fraction operator*(Fraction);
    Fraction operator/(Fraction);
    void set(int = 0, int = 1);
    void disply();
};

要求如下：

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

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

输入

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

输出

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

输入样例1 

1 3 2 5

输出样例1

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

#include<iostream>
using namespace std;
class Fraction
{
private:
    int fz, fm;
    int commonDivisor(); // 计算最大公约数
    void contracted(); // 分数化简
public:
    Fraction(int a = 0, int b = 1) : fz(a), fm(b)
    {
 
    };
    Fraction(Fraction& f)
    {
        fz = f.fz;
        fm = f.fm;
    }
    Fraction operator+(Fraction& f)  //临时对象存储
    {
        Fraction temp;
        temp.fz = fz * f.fm + fm * f.fz;
        temp.fm = fm * f.fm;
        return temp;
    }
    Fraction operator-(Fraction& f)
    {
        Fraction temp;
        temp.fz = fz * f.fm - f.fz * fm;
        temp.fm = fm * f.fm;
        return temp;
    }
    Fraction operator*(Fraction& f)
    {
        Fraction temp;
        temp.fz = fz * f.fz;
        temp.fm = fm * f.fm;
        return temp;
    }
    Fraction operator/(Fraction& f)
    {
        Fraction temp;
        temp.fz = fz * f.fm;
        temp.fm = fm * f.fz;
        return temp;
    }
    void set(int z, int m)
    {
        fz = z;
        fm = m;
    }
    void disply()
    {
        cout << "fraction=" << fz << "/" << fm << endl;
    }
};
 
int main()
{
    int fz, fm;
    cin >> fz >> fm;
    Fraction f1(fz, fm);
    cin >> fz >> fm;
    Fraction f2(fz, fm);
    Fraction f3;
 
    f3 = f1 + f2;
    f3.disply();
 
    f3 = f1 - f2;
    f3.disply();
 
    f3 = f1 * f2;
    f3.disply();
 
    f3 = f1 / f2;
    f3.disply();
}

C. 复数的加减乘运算（加减乘 全局函数）

定义一个复数类，通过重载运算符：+、-、*，实现两个复数之间的各种运算。

class Complex
{
private:
    float real, image;
public:
    Complex(float x = 0, float y = 0);
    friend Complex operator+(Complex&, Complex&);
    friend Complex operator-(Complex&, Complex&);
    friend Complex operator*(Complex&, Complex&);
    void show();
};

要求如下：

1.实现Complex类；

2.编写main函数，初始化两个Complex对象，计算它们之间的加减乘，并输出结果。

复数相乘的运算规则

设z1=a+bi，z2=c+di(a、b、c、d∈R)是任意两个复数，那么它们的积(a+bi)(c+di)=(ac-bd)+(bc+ad)i.

输入

第1行：输入两个数值，分别为第一个Complex对象的实部和虚部。

第2行：输入两个数值，分别为第二个Complex对象的实部和虚部。

输出

第1行：两个Complex对象相加后的输出结果。

第2行：两个Complex对象相减后的输出结果。

第3行：两个Complex对象相乘后的输出结果。

输入样例1

10 20
50 40

输出样例1

Real=60 Image=60
Real=-40 Image=-20
Real=-300 Image=1400

#include<iostream>
using namespace std;
class Complex
{
private:
    float real, image;
public:
    Complex(float x = 0, float y = 0) : real(x), image(y) {}
    friend Complex operator+(Complex&, Complex&);
    friend Complex operator-(Complex&, Complex&);
    friend Complex operator*(Complex&, Complex&);
    void show()
    {
        cout << "Real=" << real << " Image=" << image << endl;
    }
};
Complex operator + (Complex& c1, Complex& c2)
{
    Complex t;
    t.real = c1.real + c2.real;
    t.image = c1.image + c2.image;
    return t;
}
Complex operator - (Complex& c1, Complex& c2)
{
    Complex t;
    t.real = c1.real - c2.real;
    t.image = c1.image - c2.image;
    return t;
}
Complex operator * (Complex& c1, Complex& c2)
{
    Complex t;
    t.real = c1.real * c2.real - c1.image * c2.image;
    t.image = c1.real * c2.image + c1.image * c2.real;
    return t;
}
int main()
{
    float real, image;
    cin >> real >> image;
    Complex c1(real, image);
    cin >> real >> image;
    Complex c2(real, image);
    Complex c3;
    c3 = c1 + c2;
    c3.show();
 
    c3 = c1 - c2;
    c3.show();
 
    c3 = c1 * c2;
    c3.show();
}