C++ 中运算符重载中的参数数量

我正在学习 C++，并且创建了两个简单的 hello-world 应用程序。在这两个例子中我都使用了运算符重载，但问题就在这里。对于第一个，我可以为重载运算符提供两个参数，这很好。

Header:

enum Element {a,b,c,d,e};
Element operator + (Element x, Element y);
//more overloads for -, *, / here

Source:

Element operator + (Element x, Element y) {
    return ArrayOfElements[x][y];
}

但在我的第二个应用程序（简单的复数计算器）中 - 这种方法不起作用。经过谷歌搜索并找出原因后，我最终得到了这段代码：

Header:

struct Complex {
        double Re;
        double Im;

        Complex (double R, double I) : Re(R), Im(I) { }

        Complex operator + (Complex &Number);
        //more overloads
    };

Source:

Complex Complex::operator + (Complex &Number)
    {
        Complex tmp = Complex(0, 0);
        tmp.Re = Re + Number.Re;
        tmp.Im = Im + Number.Im;
        return tmp;
    }

它现在可以工作了，但我想知道，为什么在第一段代码中我被允许放入两个参数operator超载，但在第二个超载时出现以下错误？

complex.cpp:5:51: error: 'Complex Complex::operator+(Complex, Complex)' must take either zero or one argument

无论我是否使用类，情况都是一样的。我一直在寻找许多文档，第二种方法似乎更正确。也许是因为参数类型不同？

两个源均编译为-Wall -pedantic参数使用g++，两者都使用相同的库。

假设你有一个这样的类：

class Element {
public:
    Element(int value) : value(value) {}
    int getValue() const { return value; }
private:
    int value;
};

有四种方法可以定义二元运算符，例如+.

1. 作为一项免费功能，只能访问public班级成员：

   // Left operand is 'a'; right is 'b'.
   Element operator+(const Element& a, const Element& b) {
       return Element(a.getValue() + b.getValue());
   }
   

   e1 + e2 == operator+(e1, e2)

2. 作为成员函数，可以访问类的所有成员：

   class Element {
   public:
       // Left operand is 'this'; right is 'other'.
       Element operator+(const Element& other) const {
           return Element(value + other.value);
       }
       // ...
   };
   

   e1 + e2 == e1.operator+(e2)

3. As a friend函数，可以访问类的所有成员：

   class Element {
   public:
       // Left operand is 'a'; right is 'b'.
       friend Element operator+(const Element& a, const Element& b) {
           return a.value + b.value;
       }
       // ...
   };
   

   e1 + e2 == operator+(e1, e2)

4. As a friend在类体外部定义的函数——行为与 #3 相同：

   class Element {
   public:
       friend Element operator+(const Element&, const Element&);
       // ...
   };
   
   Element operator+(const Element& a, const Element& b) {
       return a.value + b.value;
   }
   

   e1 + e2 == operator+(e1, e2)