C++：重载数学运算符

Question

我希望重载加法运算符，并让它添加同一类的两个对象。当我在头文件的类声明中声明这个“operator+”原型函数时，我将两个对象作为参数传递。我收到编译器错误，指出“二进制‘运算符 +’有太多参数”。我在网上寻找答案，发现在编译出来的头文件中的类声明之外声明了一个内联函数。我想知道我做错了什么或者我是否在这里遗漏了一些东西。这是我在头文件中使用的代码。

class Person
{
private:
    int age;
    double weight;
public:
    Person::Person();                           //default constructor       
    Person::~Person();                           //default desctructor
    Person operator+(Person r, Person i);
};

编译时会出现我上面提到的错误。下面是编译良好的代码。

class Person
{
private:
    int age;
    double weight;
public:
    Person::Person();                           //default constructor       
    Person::~Person();                           //default desctructor
};
inline Person operator+(Person r, Person i)
{
return Person(0,0); 
}

Answer 1

如果您将 oparator+ 声明为实例函数，则第一个参数将作为 this 对象传递，因此您只需要一个参数。阅读本文以获取更多信息，特别是尝试理解 const 概念：

http://www.cs.caltech.edu/courses/cs11/material/cpp/donnie/cpp-ops.html

中建议的最佳方法引用的文章是：

class Person
{
    ...
    Person &operator+=(const Person &i);
    const Person operator+(const Person &i) const;
    ...
};

Person &Person::operator+=(const Person &i) {
    ...   // Do the compound assignment work.
    return *this;
}

const Person Person::operator+(const Person &i) const {    
    Person result = *this;     // Make a copy of myself.  Same as MyClass result(*this);
    result += i;            // Use += to add other to the copy.
    return result;              // All done!
}

如果您决定使用 const 版本，请记住您将只能在 this 和 i 上调用 const 方法参考文献。这是首选方式。

我引用的文章详细解释了首先重载 += 然后使用 += 定义 + 的想法。这是一个好主意，因为 += 运算符必须单独重载。

另外 - David Rodríguez 建议将 operator+ 实现为自由函数，而不管 += 是否存在。

Answer 2

每个成员函数都有一个隐式的第一个参数：this。对于运营商来说也是如此。因此，如果你想让 operator+() 成为一个成员，它必须只接受一个参数，即右操作数，因为左操作数已经是 this 了。

但是，对于可以是成员函数或自由函数的二元运算符，我的经验法则是使它们成为对称处理其参数的自由函数（operator+() 不会改变以下任何一个）其操作数），并将它们设为不更改的成员函数（operator+=() 更改其左操作数，但不更改其右操作数）。
此外，对于所有算术运算符，有一个很好的模式可以根据它们的组合赋值版本来实现它们。也就是说，operator+() 将基于 operator+=()，- 基于 -= 等。
除此之外，您不想不必要地复制类对象，但通常希望它们按 const 引用传递。

基于此，我的 operator+ 规范版本将是：

class Person
{
public:
    Person& operator+=(const Person& i)
    {
      // whatever
      return *this;
    }
};

inline Person operator+(Person lhs, const Person& rhs)
{
  lhs += rhs; // note: lhs passed per copy
  return lhs;
}

但是。关于运算符重载的最重要的经验法则可能是：< strong>不要这样做。这可能听起来很矛盾，但大多数情况下命名函数比运算符要好得多，因为后者使代码的可读性低于普通函数。在编写代码时，可读性应该是最重要的方面。 除非运算符在应用程序域中具有明确且无可争议的含义，否则不要为类重载它。
在您的示例中，运算符 + 应用于两个人肯定没有没有明确且无可争议的含义。在现实世界中添加到人意味着什么？ （我能想到的第一个含义不会是一个人，而是一群人。:)）
因此，除非为您的 Person 类重载此运算符是一项家庭作业，否则我强烈建议您不要这样做。 （如果这是一项作业，我会责怪老师找到这么糟糕的例子。）

Answer 3

这是一个在类中工作 += 的示例。

Vector3D& operator+=( const Vector3D& other ) {
        x+=other.x;
        y+=other.y;
        z+=other.z;
        return *this;
    }

Answer 4

根据我的阅读，最佳实践是将operator+声明为友元函数而不是成员函数。

cplusplus.com 对这个问题进行了全面的讨论：

二元运算符是朋友 - 为什么？< /a>

Meyers 在他的书《Effective C++ IIRC》中也对此进行了讨论。

引用geustgulkan的评论：

对于任何给定的二元运算符，它
执行以下操作的左手对象
操作。

假设我们有一个 ClassX 类，其中有
+ 运算符的重载
整数。那么如果我们创建一个对象
这个类（称之为 objx），然后我们
可以说 objx + 2. objx 将携带
退出操作并返回
ClassX 的结果对象。

但是如果我们说 2 + objx 会发生什么？
结果应该与 2 + 相同
objx - 但整数不是类
当然数字文字不是
- 所以 2+objx 是不可能直接实现的。

如果我们必须设计的话会很痛苦
我们的代码确保我们始终拥有
左侧的 ClassX 对象
每当我们想要时，就在 + 的一侧
添加一个 int 到它。

这是我们使用好友重载的地方
对于 ClassX 的运算符+。

class ClassX
{

    friend ClassX operator+(ClassX objx, int i);
    friend ClassX operator+(int i, ClassX objx);
};

所以你可能想要的是：

class Person
{
private:
    int age;
    double weight;
public:
    Person::Person();                           //default constructor       
    Person::~Person();                           //default desctructor
    friend Person operator+(const Person &rhs, const Person &lhs);
};

Person operator+(const Person &lhs, const Person &rhs) {
     // do whatever constitutes addition here
     Person temp = lhs;
     temp.weight += rhs.weight;
     return temp;  // return copy of temp
}

Answer 5

我只有一个建议：使用 Boost.Operators。

class Person: boost::addable<Person>      // yes private inheritance
{
public:
  Person& operator+=(Person const& rhs);

private:
};

据我所知，有两个优点：

• 无需编写样板代码，因此没有机会出错；）
• 为了提供清晰的界面，addable 几乎是不言自明的

Boost.Operators 提供了一个参考表，其中为每个行为列出了应定义的所需运算符以及将自动生成的运算符。

保持界面紧凑并将一些文档直接注入代码中非常方便。

Answer 6

似乎您进行了成员运算符+声明，无意引用任何人员实例数据：成员运算符与任何成员方法一样，接受调用它的实例作为参数。

如果由于某种原因您需要使其成为成员（例如，访问私有状态），您可以将其声明为静态。

Answer 7

我同意agsamek和履行机构的论点。我添加了一些额外的注意事项，

1. 因为您可以看到您的班级人员
   没有任何带有 2 的构造函数
   参数，这是一个错误（但是
   编译器尚未发出信号）
2. 通常当您重载一个数学运算符时，您还需要重载“operator=”和构造函数；
3. 如果你想超载加号
   有 2 个参数的运算符你不能
   使用实例成员，但您必须
   使用一个函数。我避免声明
   朋友功能因为你打破
   该类的封装（它将
   更难维护）。它是
   更好地实现一些“访问器
   方法”来获取对象的内部
   价值观；
4. 在某些编译器中，内联方法需要
   中的声明和定义
   相同的地方（通常在 .h 文件中），所以更少
   可操作的。此外，扩展
   该代码的一部分位于编译器处
   酌情权。

接下来按照我的解决方案来解决你的问题：

class Person
{
private:
    int age;
    double weight;
public:
    Person(){}                           //default constructor       
    Person(int a, double w) : age(a), weight(w) {}
    ~Person(){}                           //default desctructor

    int getAge() const { return age; }
    double getWeight() const { return weight; }

    const Person & operator =(const Person & rha) {
        age = rha.age; weight = rha.weight; return *this;
    }
};

Person operator +(const Person & lha, const Person & rha)
{
    return Person(lha.getAge() + rha.getAge(), rha.getWeight() + lha.getAge());
}

int _tmain(int argc, _TCHAR* argv[])
{
    Person p1(30,75);
    Person p2(40,80);

    Person sumOfPis = p1 + p2;  // <-- Without "operator =" this statement will use the default copy constructor

    return 0;
}

Answer 8

 class Person
  {
    private:
     int age;
     double weight;
    public:
      Person();                           //default constructor       
      ~Person();                           // destructor
      Person operator+(const Person &r); //overloaded operator as member function, so only one argument is required to be passed
 };

实现：

  Person Person::operator+(const Person &r)
  {
      Person x;
      x.age=this->age + r.age; // this refers to the object on which the function has been invoked, P1 in this case(see below)
      return x;
  }

当您重载二元运算符（在本例中为+）作为成员函数时，调用该运算符的对象将隐式传递给该函数，并且您只需要显式传递一个参数

因此您的主函数应该是这样的

 int main()
 {
    Person P1,P2;
    P2=P1+P2; //P1 is passed implicitly 

    //The above expression is equivalent to P2=P1.operator+(P2);
}