C++ 中的运算符重载

Question

我需要在 C++ 中重载 * 运算符。因此，我创建了一个名为 Element 的类，它必须重载该运算符才能处理其中存储的双精度值。这就是我在实现文件中所做的：

#include "Element.h"
#include <iostream>

using namespace std;

// Other code that is not relevant

Element Element::operator * ( const Element &obj)
{
    d *= obj.d;
    return *this;
}

这不起作用。它抛出一个错误说：“'8 * c'中的'operator *'不匹配

在我的主文件中：

d = a = 8 * c - 4 + b;

其中d，a，c和b都是Element类的对象

Answer 1

您确实必须了解您在这里所做的事情，您正在重载 Element 类的“*”运算符，但您这样做的同时期望另一个元素具有“参数”。

您编写的代码实际上期望这种代码

Element v, w, a;
a = v * w;

如上所述，您可能需要看一下： http://www.learncpp.com/cpp-tutorial/92-overloading-the-arithmetic-operators/

Answer 2

这是因为您仅对 Element * Element 重载了运算符 *，而对于 c * 8 您必须实现 Element Element::operator * ( const int i)

Answer 3

您可以将 8 * c 表达式 (int, Element) 与非成员重载相匹配，例如

Element operator* (const Element& leftHandSide, const Element& rightHandSide){
   return Element( leftHandSide.d * rightHandSide.d);
}

通过使用 const Element& 您可以使用带有 Element::Element 等签名的构造函数(int ) 用于类型转换。

Answer 4

您现有的运算符实现允许您将两个 Element 对象相乘。
但是，根据“主文件”中的客户端代码，您需要能够将 Element 对象乘以标量值；在本例中为 8。

所以你需要的是一个额外的运算符，它将双精度作为其参数：
如下所示：

Element Element::operator * ( const double scalar ) const
{
    const Element e( d * scalar );
    return e;
}

这里我假设您的 Element 类有一个构造函数，该构造函数采用单个标量参数，并将其分配给 d。

另请注意，您现有的运算符 * 实现在语义上很奇怪，
因为它改变了 d 的内部状态（使用 *= ）。
这几乎肯定不是你想要的......

Answer 5

我为您提供了一个解决方案，并针对您的操作员过载发出了警告。

解决方案：

#include <iostream>
using namespace std;

struct Element {
    double d;
    Element(double d) {this->d = d;}
    Element operator*(const Element &obj) {
        d *= obj.d;
        return *this;
    }
};

Element operator*(const int i, const Element& e) {
    return Element(static_cast<double>(i) * e.d);
}

ostream& operator<<(ostream& os, const Element& e) {
    os << e.d;
    return os;
}

int main() {
        Element e(2);
        cout << "Product of 8 and e: " << 8*e << '\n';

        // This shows why your overload is a bad idea:
        Element a(3);
        cout << "a is " << a << '\n'; // prints 3
        cout << "Now its product with e is: " << a*e << '\n'; // prints 6
        cout << "Surprise: a is now " << a << '\n'; // prints 6
}

您原来的重载不起作用，因为它甚至没有被调用。您的表达式类似于

a = 8*c

其中 8 是 int 类型，当 C++ 从左到右解析该表达式时，它会看到 8 是 int 类型，并尝试在 int 类型中搜索运算符*(const Element&) 的重载，并且它找不到它，因为它不知道也不应该知道有关您自己的用户定义类型的任何信息。因此，如果您希望自己的类与其他类型交互，您要么需要将operator* 的重载作为成员函数嵌入到其他类型中，要么像我在解决方案中所做的那样将其声明为外部函数。

现在警告。您的原始运算符重载定义不明确，因为它修改了原始对象，这被认为是意外行为。我在上面的代码中展示了这一点。这就像 8 乘以 2 得到 16，但同时从 8 得到 16。你真正想做的是在乘法运算符中创建一个新元素并返回它：

struct Element {
    double d;
    Element(double d) {this->d = d;}
    Element operator*( const Element &obj) {
        return Element(this->d * obj.d);
    }
};

该死的这些答案太糟糕了时间...我应该工作：\