1

我很难知道自己做错了什么。

Huge& Huge::operator *=(const Huge& h) {
    Huge retHuge = *this * h;
    string out1 = retHuge.toString(); // for debugging purposes
    return *this = retHuge;
//  return retHuge;
}

这

Huge retHuge = *this * h;

我在字符串中验证时工作正常out1。如果我返回 retHuge 并在调用例程中打印结果，我可以看到原始的 this 保持不变。如果我执行 a*this = retHuge并返回*this，我会SEGSEGV出错。

调用析构函数清理内存并在乘法后返回结果的正确方法是什么？

我要感谢大家的回答。Crazy Eddie 使用了我所拥有的并对其进行了扩展，这正是我想做的。我更改了来源以反映他的建议，并且出现了 SEGSEGV 故障。

我认为这意味着我的语法必须基本正确，但我的其余代码中隐藏了一个错误。这是有价值的信息，我需要回去仔细查看是否能找到一些东西。我不想在没有做好功课之前偷懒和寻求帮助，所以我先好好看看。

我的经验主要是 Java，它有一个很好的未引用对象垃圾收集器。我将使用调试器并验证是否正在调用我的析构函数来释放内存。

这是一个很好的提示，首先尝试执行 *= 运算符，然后从中构建 = 运算符。很明显，我做了相反的事情。您的回答似乎仍然表明我所做的确实应该有效。既然不行，那我就回去看看能不能找到什么。如果我做完作业后还是找不到任何东西，我会继续问。与此同时，感谢所有的帮助。

4

4 回答 4

8

适用于您的特定情况的重载算术运算符的规范形式：

Huge& Huge::operator *=(const Huge& h) // class member function
{
  // somehow multiply h's value into this' value
  return *this;
}


Huge operator*(Huge lhs, const Huge& rhs) // free function; note lhs being copied
{
  lhs *= rhs;  // *= already implemented above
  return lhs;
}

这里根本不涉及动态内存，因此您不需要删除任何内存。

根据运算符重载经验法则，复合赋值表单应该是一个成员，因为它改变了它的左操作数（并且可能需要访问类的私有部分）。非赋值版本应该是一个自由成员函数，以便隐式转换可以平等地应用于两个操作数。

于 2012-05-06T11:23:35.660 回答
2

不要；_ delete this之后，*this正在写入未分配的内存。

相反，只需说*this = retHuge（不带delete this），然后return *this。

operator =改为处理释放。

这是一个完整的示例，带有一个虚构的复杂有效负载 a int *：

#include <iostream>

class A {
public:
    A(int _val): val(new int(_val))
    { }

    ~A() {
        delete this->val;
    }

    A &operator =(const A &r) {
        // Pretend this->val is complex and we need to reallocate the
        // entire thing.
        delete this->val;

        this->val = new int(*r.val);

        return *this;
    }

    A operator *(const A &r) const {
        return A(*this->val * *r.val);
    }

    A &operator *=(const A &r) {
        return *this = *this * r;
    }

    int *val;
};

int main() {
    A x(5), y(10);
    x *= y;

    std::cout << "x: " << *x.val << ", y: " << *y.val << std::endl;
    return 0;
}
于 2012-05-06T11:04:10.813 回答
1

由于您似乎已经有了 * 运算符，并且我假设此时分配有效，这将是最好的实现：

Huge& Huge::operator *=(const Huge& h) {
    Huge retHuge = *this * h;

    return *this = retHuge;
}
于 2012-05-06T11:39:53.333 回答
0

operator=意味着您将右手站点分配到此.

所以，你应该改变this的内容，然后最后return *this;

于 2012-05-06T11:04:53.700 回答