Создать класс для выполнения арифметических действий с комплексными рациональными дробями

#include <iostream>
#include <ostream>
 
template<typename T>
struct Fraction {
    T numerator;
    T denominator;
    Fraction(): numerator{0}, denominator{1} {}
    Fraction(T number): numerator(number), denominator{1} {}
    Fraction(T numerator, T denominator): numerator(numerator), denominator(denominator) {}
};
 
template<typename T>
std::ostream &operator<<(std::ostream &out, const Fraction<T> &fraction) {
    return out << fraction.numerator << "/" << fraction.denominator;
}
 
template<typename T>
Fraction<T> operator+(const Fraction<T> &a, const Fraction<T> &b) {
    return {a.numerator * b.denominator + b.numerator * a.denominator, a.denominator * b.denominator};
}
 
template<typename T>
Fraction<T> operator-(const Fraction<T> &a, const Fraction<T> &b) {
    return {a.numerator * b.denominator - b.numerator * a.denominator, a.denominator * b.denominator};
}
 
template<typename T>
Fraction<T> operator*(const Fraction<T> &a, const Fraction<T> &b) {
    return {a.numerator * b.numerator, a.denominator * b.denominator};
}
 
template<typename T>
Fraction<T> operator/(const Fraction<T> &a, const Fraction<T> &b) {
    return {a.numerator * b.denominator, a.denominator * b.numerator};
}
 
template<typename T>
Fraction<T> operator-(const Fraction<T> &f) {
    return {-f.numerator, f.denominator};
}
 
template<typename T>
Fraction<T> operator++(const Fraction<T> &f) {
    return {f.numerator + f.denominator, f.denominator};
}
 
template<typename T>
Fraction<T> operator--(const Fraction<T> &f) {
    return {f.numerator - f.denominator, f.denominator};
}
 
template<typename T>
bool operator==(const Fraction<T> &a, const Fraction<T> &b) {
    // не сработает для неупрощённых дробей.
    return (a.numerator == b.numerator) && (a.denominator == b.denominator);
}
 
// для целых чисел
int gcd(int a, int b) {
    // no hard feelings, negative numbers...
    a = std::abs(a);
    b = std::abs(b);
    while (a != 0 && b != 0) {
        if (a > b) {
            a %= b;
        } else {
            b %= a;
        }
    }
    return a + b;
}
 
template<typename T>
struct Complex {
    T real;
    T imaginary;
    Complex() : real{0}, imaginary{0} {}
    Complex(int real) : real{real}, imaginary{0} {}
    Complex(int real, int imaginary) : real{real}, imaginary{imaginary} {}
};
 
 
// наивный подход.
// просто взять все четыре числа комплексной дроби и найти у них гцд
template<typename T>
int gcd(const Complex<T> &a, const Complex<T> &b) {
    return gcd(gcd(a.real, b.real), gcd(a.imaginary, b.imaginary));
}
 
// собственно упрощоение такой дроби
template<typename T>
Fraction<Complex<T>> simplify(const Fraction<Complex<T>> &f) {
    int divisor = gcd(f.numerator, f.denominator);
    return {f.numerator / divisor, f.denominator / divisor};
}
 
template<typename T>
bool operator==(const Fraction<Complex<T>> &a, const Fraction<Complex<T>> &b) {
    auto c = simplify(a);
    auto d = simplify(b);
    return (c.numerator == d.numerator) && (c.denominator == d.denominator);
}
 
 
template<typename T>
Complex<T> operator+(const Complex<T> &a, const Complex<T> &b) {
    return {a.real + b.real, a.imaginary + b.imaginary};
}
 
template<typename T>
Complex<T> operator-(const Complex<T> &a, const Complex<T> &b) {
    return {a.real - b.real, a.imaginary - b.imaginary};
}
 
template<typename T>
Complex<T> operator-(const Complex<T> &a) {
    return {-a.real, -a.imaginary};
}
 
template<typename T>
Complex<T> operator*(const Complex<T> &a, const Complex<T> &b) {
    return {a.real * b.real - a.imaginary, a.real * b.imaginary - b.real * a.imaginary};
}
 
template<typename T>
Complex<T> operator/(const Complex<T> &a, int scalar) {
    return {a.real / scalar, a.imaginary / scalar};
}
 
template<typename T>
bool operator==(const Complex<T> &a, const Complex<T> &b) {
    return (a.real == b.real) && (a.imaginary == b.imaginary);
}
 
template<typename T>
std::ostream &operator<<(std::ostream &out, const Complex<T> &complex) {
    out << "(" << complex.real;
    if (complex.imaginary >= 0) {
        out << "+";
    }
    return out << complex.imaginary << "i)";
}
 
int main() {
    Fraction<Complex<int>> a({1, 2}, {2, -1});
    Fraction<Complex<int>> b({2, 4}, {4, -2});
    std::cout << simplify(a + b) << std::endl;
    std::cout << simplify(a - b) << std::endl;
    std::cout << simplify(a * b) << std::endl;
    std::cout << simplify(a / b) << std::endl;
    std::cout << std::boolalpha << (a == b) << std::endl;
}