Question

我有多个错误表示"<snippet of code> needs zero or one argument"或"<snippet of code> needs exactly one argument."为了简单起见，我只会发布我的file.h和file.cc中的其中一段代码。我不认为我的main.cc有什么问题。此外，该函数必须是类friend的{{1}}函数，因此我不能将其作为不同类型的函数或仅使用访问器函数。任何人都可以提供的帮助将是非常感谢。谢谢！

file.cc

（my_int类的朋友功能）：

my_int

file.h

（在名为my_int my_int::operator+(const my_int& num1, const my_int& num2) { my_int temp; temp = num1 + num2; return(temp); }的类中）

my_int

Answer 1

friend my_int operator+(const my_int& num1, const my_int& num2);

表示'声明一个带2个参数的自由函数。把它变成朋友，这样就可以看到我的私人成员了

my_int my_int::operator+(const my_int& num1, const my_int& num2) {

表示'定义（非法）成员函数operator +，它总共需要3个参数。

编辑：根据要求，添加更多信息。

有许多“正确”的方法可以在您的类上实现运算符。 “最佳实践”方法是将所有二元运算符实现为自由函数（运算符+作为自由函数使用2个参数声明）。运算符+应尽可能在operator + =（一元运算符，因此在类中定义）中实现。这是最佳实践，因为它允许您编写将不同对象作为参数的operator +的重载。例如：

struct X {
  explicit X(int val) : _val (val) {}

  // getter
  int value() const { return _val; }

  // this helper += operator eases our journey later on
  X& operator+=(int delta) {
    _val += delta;
    return *this;
  }

  X& operator+=(const X& r) {
    _value += r.value();
    return *this;
  }

private:
  int _val;
}

// implements X + X
X operator+(X l, const X& r)
{
  return l += r;
}

// implements X + int
X operator+(X l, int r)
{

  return l += r;
}

// implement int + X (returns an X)
X operator+(int l, X r) {
  return r += l;
  return r;
}

// later, someone else defines a Y and wants it to be addable with X, returning a Z

struct Y {
  vector<int> get_numbers() const;
}

struct Z {
  Z(vector<int> v);
}

// implement Z = X + Y;
Z operator+(const X& l, const Y& r) {
  auto v = r.get_numbers(); // vector<int> instead of auto for c++03
  v.push_back(l.value());
  return Z { std::move(v) }; // c++11
// return Z(v); // c++03
}

// also implement Z = Y + X
Z operator+(const Y&l , const X&r) {
  auto v = l.get_numbers();
  v.push_back(r.value());
  return Z { std::move(v) };
}

请注意，可以将二元运算符的自由函数形式声明为朋友：

struct X {
  // this is a free function - not a class memeber, but it can see X::_value
  friend X operator+(X, const X&);
private:
  int _value;
};

// implementation
X operator+(X l, const X& r) {
  l._value += r._value;
  return l;
}

但我认为这种风格不如写一些真正的未绑定的自由二元运算符，这些运算符是用一元运算符实现的（上图）。

也可以将二元运算符实现为成员函数 - 在这种情况下，使用一个参数声明和定义它们（另一个隐含为this）：

struct X {
  X operator+(X r);
private:
  int _value;
};

X X::operator+(const X& r) {
  // l is implied as *this
  return X { _value + r._value };
}

但这是一个错误，因为虽然它允许重载（X + int），但它不允许重载（int + X），无论如何你都需要一个自由函数。

Answer 2

此方法：

my_int my_int::operator+(const my_int& num1, const my_int& num2);

是会员功能。成员函数运算符隐式地将this指向的对象（它将是my_int对象）作为其左参数。这意味着您的重载参数声明不能包含多个对象。将您的签名更改为：

my_int my_int::operator+(const my_int& num2);

现在num1之前的内容现在是*this。

Answer 3

运算符+可用于两种表达式：

一元“加”表达式：+a
二进制“加”表达式：a + b

对于两种表达式，运算符都是可重载的。每个重载必须是一元或二元的。如果重载是成员函数，则隐式实例参数提供第一个操作数。

所以你有这些选择：

免费功能

R operator+(T a)

+a

a有资格获得T。

S operator+(T lhs, U rhs);

a + b

a

T

b符合U的要求。

会员功能：

 struct Foo
 {
     R operator+();        // #1
     S operator+(T rhs);   // #2
 } x;

超载＃1有资格获得+x。
当x + b可转换为b时，超载＃2有资格获得U。

运算符需要零个或一个参数

3 个答案: