怎样编写C++中的运算符重载 成员函数与全局函数实现方式

class Vector {
private:
    double x, y;
public:
    Vector(double x = 0, double y = 0) : x(x), y(y) {}

    // 重载加法运算符 +
    Vector operator+(const Vector& other) const {
        return Vector(x + other.x, y + other.y);
    }

    // 重载输出运算符 << (友元函数方式，后面会讲)
    friend std::ostream& operator<<(std::ostream& os, const Vector& v);
};

std::ostream& operator<<(std::ostream& os, const Vector& v) {
    os << "(" << v.x << ", " << v.y << ")";
    return os;
}

int main() {
    Vector v1(1, 2);
    Vector v2(3, 4);
    Vector v3 = v1 + v2; // 使用重载的 + 运算符
    std::cout << v3 << std::endl; // 输出 (4, 6)
    return 0;
}

class Complex {
private:
    double real, imag;
public:
    Complex(double real = 0, double imag = 0) : real(real), imag(imag) {}

    // 声明友元函数，允许全局函数访问私有成员
    friend Complex operator+(const Complex& c1, const Complex& c2);

    friend std::ostream& operator<<(std::ostream& os, const Complex& c);
};

// 重载加法运算符 +，全局函数方式
Complex operator+(const Complex& c1, const Complex& c2) {
    return Complex(c1.real + c2.real, c1.imag + c2.imag);
}

std::ostream& operator<<(std::ostream& os, const Complex& c) {
    os << c.real << "+" << c.imag << "i";
    return os;
}


int main() {
    Complex c1(1, 2);
    Complex c2(3, 4);
    Complex c3 = c1 + c2; // 使用重载的 + 运算符
    std::cout << c3 << std::endl; // 输出 4+6i
    return 0;
}

class Fraction {
private:
    int numerator, denominator;
public:
    Fraction(int numerator, int denominator) : numerator(numerator), denominator(denominator) {
        if (denominator == 0) {
            throw std::invalid_argument("Denominator cannot be zero.");
        }
    }

    Fraction operator/(const Fraction& other) const {
        if (other.numerator == 0) {
            throw std::runtime_error("Cannot divide by zero.");
        }
        return Fraction(numerator * other.denominator, denominator * other.numerator);
    }
};

int main() {
    try {
        Fraction f1(1, 2);
        Fraction f2(0, 1);
        Fraction f3 = f1 / f2; // 可能抛出异常
    } catch (const std::exception& e) {
        std::cerr << "Exception: " << e.what() << std::endl; // 输出错误信息
    }
    return 0;
}

template <typename T>
class MyNumber {
private:
    T value;
public:
    MyNumber(T value) : value(value) {}

    MyNumber operator+(const MyNumber& other) const {
        return MyNumber(value + other.value);
    }

    friend std::ostream& operator<<(std::ostream& os, const MyNumber& num) {
        os << num.value;
        return os;
    }
};

int main() {
    MyNumber<int> num1(10);
    MyNumber<int> num2(20);
    MyNumber<int> num3 = num1 + num2;
    std::cout << num3 << std::endl; // 输出 30

    MyNumber<double> d1(3.14);
    MyNumber<double> d2(2.71);
    MyNumber<double> d3 = d1 + d2;
    std::cout << d3 << std::endl; // 输出 5.85
    return 0;
}