Question

我有一个关于运算符重载的问题。下面是我的示例代码。如果您可以阅读它，我的问题如下。

//class definition
class example
{
private:
    int a ; // Defined in FeetInches.cpp
public:
    void seta(int f)
    {
        a = f;
    }
    example operator + (const example &); // Overloaded +

    int geta()
    {
        return a;
    }
};

example example::operator + (const example &right)
{
    example temp;

    temp.a = a + right.a;
    return temp;
}

//主

#include "header" //this is the class definition above
#include <iostream>
using namespace std;

int main()
{
    example r;
    r.seta(1);

    example s;
    s.seta(1);

    example t;
    t = r + s;
    t = r + 1;  //if included it won't compile
    t = 1 + r; //if included it won't compile

    int x = t.geta();
    cout << x;

    cin.get();
    return 0;
}

据我所知，当您尝试使用运算符重载将对象添加到一起时，它们应该是相同的。

以下是问题：我最近看到的对象是在它编译的运算符的一侧，但是当它在另一侧时却没有。如：

它编译了{p> t = r + 1;。 t = 1 + r;它没有。

（另外我知道在我的例子中，它无论如何都不起作用，但更容易用代码构建问题。）

当对象位于运算符的一侧但是当它在另一侧时不编译时，如何编译运算符重载。

由于

Answer 1

如果你详细地重写有问题的陈述，它看起来像是：

t.operator=(1.operator+(r));

这没有多大意义并且混淆了编译器。

混淆，它可以将数字1转换为example的实例，或将变量r转换为整数。不幸的是，你在课堂上没有提供足够的信息。

如果你为你的类提供一个带整数的构造函数，那么事情可能会变得更加混乱：

class example
{
  public:
    example(int new_value) : a(new_value)
      { ; }
};

现在，您已为编译器提供了将整数转换为example的方法。

另一种方法是提供一个转换或转换运算符：

class example
{
  public:
    int operator int (const example& e)
    {
      return e.a;
    }
};

还有其他替代方法，例如创建采用整数的加法方法。

编辑1：
如果您正在设计单位类，请注意常量。你不知道常数是什么单位，比如英尺或英寸。编译器将无法提供帮助，因为数字常量没有与之关联的单位。

Answer 2

这很简单，当您重载运算符时，您可以通过两种方式执行此操作：

首先就像你这样做。您为其中的类插入了重载运算符。这样左参数必须是此类的对象。为什么？因为当您调用此运算符时，您可以将其作为类中每个函数的调用来执行。你不能以其他方式去做，因为你不能用其他类型来调用这个函数。

其次，您将重载运算符作为您的类的朋友。在你的班上你把这行：

 friend example& operator + (const example &left, const example &right);

在你的课程定义之后，你把它放在：

example& operator + (const example &left, const example &right){...}

因此，如果要添加整数或其他类型，则必须修改运算符以将其添加为：

example& operator + (const example &left, const int right){...}

或者这个：

example& operator + (const int left, const example &right){...}

如果要从操作员的左侧或右侧添加int，请选择一个或两个。

Answer 3

如果t = r + 1;定义了匹配的t = r.operator+(1);方法，则

r表示operator+()，否则意味着t = operator+(r, 1);。它没有编译，因为你没有定义任何+运算符，左边是example，右边是int，例如：

// as a class method:

class example
{
    ...
public:
    ...
    example operator + (int right) const;
};

example example::operator + (int right) const
{
    example temp;
    temp.seta(a + right);
    return temp;
}

或者：

// as a global operator:

class example
{
    ...
public:
    ...
    friend example operator + (const example& left, int right);
};

example operator + (const example& left, int right)
{
    example temp;
    temp.seta(left.a + right);
    return temp;
}

如果您定义了一个以int作为输入的构造函数，那么当您将example值传递给int方法时，编译器可能已经创建了一个临时example::operator+(const example&) ，例如：

class example
{
    ...
public:
    example (int f);
    ...
    example operator + (const example& right);
};

example::example::(int f)
    : a(f)
{
}

example example::operator + (const example& right)
{
    example temp;
    temp.a = a + right.a;
    return temp;
}

同样，t = 1 + r;表示t = operator+(1, r);（因为1不是类类型）。它没有编译，因为你没有定义一个全局+运算符，左边是int，右边是example：

class example
{
    ...
public:
    ...
    friend example operator + (int left, const example& right);
};

example operator + (int left, const example& right)
{
    example temp;
    temp.a = left + right.a;
    return temp;
}

为什么我的操作符重载处理左对象和右对象？

3 个答案: