【c++习题】【17/5/8】重载运算符

1、设计一个Complex（复数）类，完成如下要求：

该类具有实部（Real_Part）和虚部（Image_Part）
通过重载运算符“+”实现两个复数的相加
通过重载运算符“+”实现一个复数与一个数值的相加，其结果为复数的实部加上这个数值
重载“-”运算符，实现复数的减法。
重载“++”运算符，实现复数实部的自增
重载“>>”运算符和 “<<”运算符，实现复数的输入和输出
重载“==”，判断两个复数是否相等
提示：输入输出运算符只能重载为类的友元函数，形式如下
 friend ostream &operator<<(ostream &os,const Complex &c); friend istream &operator>>(istream &is,Complex &c);

#include <cstdio>
#include <iostream.h> // vc 6.0
#include <string>
#include <cstring>
#include <vector>
// using namespace std;

class Complex {

friend ostream &operator<<(ostream &os,const Complex &c);
friend istream &operator>>(istream &is,Complex &c);

friend Complex operator+(const Complex &c1,const Complex &c2);
friend Complex operator+(const Complex &c1,int num);
friend Complex operator-(const Complex &c1,const Complex &c2);

friend bool operator==(const Complex &c1,const Complex &c2);

public:
    Complex(): r(0), i(0) {}
    Complex(int r, int i): r(r), i(i) {}

    Complex& operator++() { 
        ++r;
        return *this;
    }

    const Complex operator++(int) { 
        r++;
        return *this;
    }

private:
    int r, i;
};

ostream &operator<<(ostream &os,const Complex &c) {
    os << c.r << "+" << c.i << "i\n";
    return os;
}

istream &operator>>(istream &is,Complex &c) {
    is >> c.r >> c.i;
    return is;
}

Complex operator+(const Complex &c1,const Complex &c2) {
    Complex x;
    x.r = c1.r + c2.r;
    x.i = c1.i + c2.i;
    return x;
}

Complex operator+(const Complex &c1,int num) {
    Complex x;
    x.r = c1.r + num;
    x.i = c1.i;
    return x;
}

Complex operator-(const Complex &c1,const Complex &c2) {
    Complex x;
    x.r = c1.r - c2.r;
    x.i = c1.i - c2.i;
    return x;
}

bool operator==(const Complex &c1,const Complex &c2) {
    if (c1.r == c2.r && c1.i == c2.i) return true;
    return false;
}

void testIO() {
    Complex x(3, 2);
    cout << x;
    cin >> x;
    cout << x;
}

void testAdd() {
    Complex c1(2, 2);
    Complex c2(3, 3);
    cout << c1 - c2 + 1 << endl;
}

void testAdd2() {
    Complex x1, x2;
    x1 = x2++;
    cout << x1 << endl;
    // cout << x << endl;
}

void testEqual() {
    Complex x1, x2;
    cout << (x1 == x2) << endl;
}

int main()
{
    // testIO();
    // testAdd();
    // testAdd2();*
    testEqual();
    return 0;
}

 

2. 问题描述：有理数是一个可以化为一个分数的数，例如2/3，533/920，-12/49都是有理数，而√2就为无理数。在C++中，并没有预先定义有理数，需要时可以定义一个有理数类，将有理数的分子和分母分别存放在两个整型变量中。对有理数的各种操作都可以用重载运算符来实现。
基本要求： 定义并实现一个有理数类，通过重载运算符+、-、*、/对有理数进行算术运算，通过重载运算符==实现判定两个有理数是否相等。写一个优化函数，它的作用是使有理数约去公分母(4/6=2/3)，也即是使保存的有理数分子和分母之间没有公约数（除去1以外）。

Ⅰ、未重载运算符版

#include <iostream>
#include <cstdio>
#include <string>
using namespace std;

class Number {
friend void print(Number& x);
friend int gcd(int a, int b);
private:
    int m;
    int n;
public:
    Number(): m(0) {}
    Number(int m, int n): m(m), n(n) {}
    void add(Number& b) {
        m = m * b.n + n * b.m;
        n = n * b.n;
        stdlize();
    }
    void minus(Number& b) {
        m = m * b.n - n * b.m;
        n = n * b.n;
        stdlize();
    }
    void multi(Number& b) {
        m = m * b.m;
        n = n * b.n;
        stdlize();
    }
    void divide(Number& b) {
        m = m / b.m;
        n = n / b.n;
        stdlize();
    }
    void stdlize() {
        int x = gcd(m, n);
        m = m / x;
        n = n / x;
    }
};

int gcd(int a, int b)
{
    int m = a, n = b, r = -1;
    while (r != 0) {
        r = m % n;
        m = n;
        n = r;
    }
    return m;
}

void print(Number& x)
{
    printf("%d/%d\n", x.m, x.n);
}

int main()
{
    // test add
    printf("test add: 1/15 + 4/15 = ");
    Number a(1, 15);
    Number b(4, 15);
    a.add(b);
    print(a);

    // test minus
    printf("test minus: 2/3 - 1/3 = ");
    Number c(2, 3);
    Number d(1, 3);
    c.minus(d);
    print(c);

    // test multi    
    printf("test multi: 2/4 * 4/3 = ");
    Number e(2, 4);
    Number f(4, 3);
    e.multi(f);
    print(e);

    // test divide
    printf("test divide: 1/12 div 1/3 = ");
    Number g(1, 12);
    Number h(1, 3);
    g.divide(h);
    print(g);

    return 0;
}


 
 

Ⅱ、重载运算符版（待）

 

3、自定义一个Array类，可以根据下标和上标分配空间，并自动判断是否溢出，定义函数实现对数据的赋值，删除等操作。自行编写测试函数实现可以对输入数组的下标和上标，根据其下标和上标分配内存空间并赋值，重载赋值运算符 << 与=可以实现将一个数组的输出与 a1=a2的操作。

#include <cstdio>
#include <iostream.h> // vc 6.0
#include <string>
#include <cstring>
#include <vector>
// using namespace std;

class Array {

friend istream &operator>>(istream &is, Array &arr); 
friend ostream &operator<<(ostream &os, Array &arr); 

public:
    Array(int begin, int end): begin(begin), end(end) {
        arr = new int[end-begin+1];
    }
    ~Array() {
        delete []arr;
    }
private:
    int *arr;
    int begin, end;
};

istream &operator>>(istream &is, Array &arr) {
    for (int i = arr.begin; i <= arr.end; ++i) {
        is >> arr.arr[i-arr.begin];
    }
    return is;
}

ostream &operator<<(ostream &os, Array &arr) {
    for (int i = arr.begin; i <= arr.end; ++i) {
        os << arr.arr[i-arr.begin] << " ";
    }
    os << endl;
    return os;
}

int main()
{
    Array arr(0,1); // arr[0]. arr[1]
    cin >> arr;
    cout << arr;
    
    return 0;
}