将不同的参数传递给重载运算符函数

Passing different parameters to an overloaded operator function

本文关键字：重载 运算符 函数 参数传递      更新时间：2023-10-16

我目前有一个名为 Complex 的类：

class Complex{
public:
    Complex();
    Complex(double, double);
    double r, i;
    void read(istream &in);
    void display(ostream &out) const;
    double real, imaginary;

我用来重载加法运算符。目前我有三个单独的函数声明来处理 3 种不同的情况：右侧的 2 个复数、1 个复数和 1 个 int，右侧的 1 个 int 和 1 个复数。

Complex operator+ (const Complex& num1, const Complex& num2);
Complex operator+ (const int num1, const Complex& num2);
Complex operator+ (const Complex& num1,const int num2);
函数声明都只是将复数的"实数"

和"虚数"部分相加，并将整数添加到复数的实部。

Complex operator+ (const Complex& num1,const Complex& num2) {
    Complex result;
    result.real += num1.real + num2.real;
    result.imaginary += num1.imaginary +num2.imaginary;
    return result;
}
Complex operator+ (const int num1, const Complex& num2){
    Complex result;
    result.real += num1;
    result.imaginary += num2.imaginary;
    return result;
}
Complex operator+ (const Complex& num1, const int num2){
    Complex result;
    result.real += num2;
    result.imaginary += num1.imaginary;
    return result;
}

一定有更好的方法可以做到这一点吧？还是所有三个案例都必须明确声明？

如果将

委派构造函数添加到Complex类。

class Complex{
public:
    Complex();
    Complex(double, double);
    Complex(double a) : Complex(a, 0) {}

然后你会发现你只需要定义一个operator+：

Complex operator+(const Complex &a, const Complex &b);

它将处理示例中的所有用例。

首先，函数中的代码过于复杂。您绝对应该使用其双参数构造函数初始化result，而不是初始化为零然后修改。例如，代码可以是：

Complex operator+ (const Complex& num1,const Complex& num2)
{
    return Complex(num1.real + num2.real, num1.imaginary + num2.imaginary);
}
Complex operator+ (const Complex& num1, const int num2)
{
    return Complex(num1.real + num2, num1.imaginary);
}
Complex operator+ (const int num1, const Complex& num2)
{
    return num2 + num1;    // compiler will inline this
}

我不确定你为什么在这里使用int，使用double似乎更好.

Sam 的回答展示了如何将三个函数减少到 1。这减少了您必须执行的键入量，尽管它确实会略微降低性能：您最终会对返回值的imaginary进行额外的+ 0.0。

如果我们展望乘法，那么这个惩罚会更严重一些，例如代码：

Complex operator*(Complex const &lhs, double rhs)
{
    return Complex(lhs.real * rhs, lhs.imaginary * rhs);
}

比 Complex operator*(Complex const &lhs, Complex const &rhs) 中的代码执行的操作少得多。

因此，您必须在代码简单性和性能之间做出选择。

相关文章：