C+中的运算符重载+； 我需要在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; }

其中d、a、c和b都是类Element的对象，这是因为您只为

Element*Element

重载了operator*，而对于

c*8

您必须实现

Element Element:：operator*（const int i）

，这是因为您只为

Element*Element

重载了operator*，对于

c*8

您必须实现

Element Element:：operator*（const int i）

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

您编写的代码实际上需要这种代码

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

---

如前所述，您可能需要了解：

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

您编写的代码实际上需要这种代码

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

---

如前所述，您可能想了解一下：

您现有的操作符实现允许您将两个

元素

对象相乘。 但是，根据“主文件”中的客户机代码，您需要能够将元素对象乘以标量值；8在这种情况下

因此，您需要的是一个附加运算符，它将double作为其参数： 如下所示：

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

这里我假设您的元素类有一个构造函数，它接受一个标量参数，并将其分配给d

还要注意，运算符*的现有实现在语义上是奇怪的， 因为它改变了d的内部状态（带*=）。

---

这几乎肯定不是您想要的…

您现有的运算符实现允许您将两个

元素

对象相乘。 但是，根据“主文件”中的客户机代码，您需要能够将元素对象乘以标量值；8在这种情况下

因此，您需要的是一个附加运算符，它将double作为其参数： 如下所示：

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

这里我假设您的元素类有一个构造函数，它接受一个标量参数，并将其分配给d

还要注意，运算符*的现有实现在语义上是奇怪的， 因为它改变了d的内部状态（带*=）。

---

这几乎肯定不是您想要的…

您可以将8*c表达式（int，Element）与非成员重载匹配，如

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

---

通过使用

const-Element&

可以使用带有签名的构造函数，如

Element:：Element（int）

进行类型转换

您可以将8*c表达式（int，Element）与非成员重载匹配，如

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

---

通过使用

const-Element&

可以使用带有签名的构造函数，如

Element:：Element（int）

进行类型转换

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

解决方案：

#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
}

其中8是int类型，当C++从左到右解析这个表达式时，它会看到8是int类型，并试图在int类型中搜索运算符*（const元素）的超载，并且它找不到它，因为它不知道并且不应该知道关于您自己的用户定义类型的任何东西。因此，如果希望自己的类与其他类型交互，则需要将运算符*重载作为成员函数嵌入到其他类型中，或者像我在解决方案中所做的那样将其声明为外部函数

现在是警告。原始运算符重载定义不正确，因为它会修改原始对象，这被认为是意外行为。我在上面的代码中显示了这一点。这就像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);
    }
};

---

该死的这些答案花了很多时间。。。我应该在工作：\

我有一个解决方案给你，还有一个警告给你的操作员过载

解决方案：

#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
}

其中8是int类型，当C++从左到右解析这个表达式时，它会看到8是int类型，并试图在int类型中搜索运算符*（const元素）的超载，并且它找不到它，因为它不知道并且不应该知道关于您自己的用户定义类型的任何东西。因此，如果希望自己的类与其他类型交互，则需要将运算符*重载作为成员函数嵌入到其他类型中，或者像我在解决方案中所做的那样将其声明为外部函数

现在是警告。原始运算符重载定义不正确，因为它会修改原始对象，这被认为是意外行为。我在上面的代码中显示了这一点。这就像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);
    }
};

---

该死的这些答案花了很多时间。。。不过我应该在工作：\

我会推荐。谢谢，我会查出来8不是

元素。它被视为一个整数。您显示的代码只允许两个
元素的乘法。那么如何使它与一个元素和一个整数的乘法一起工作？阅读下面的答案如何？这里有不止一个例子……我会推荐。谢谢，我会检查它8不是
元素。它被视为一个整数。您显示的代码只允许两个
元素的乘法。那么如何使它与一个元素和一个整数的乘法一起工作？阅读下面的内容如何