Question

#include <iostream>
using namespace std;

class Distance
{
   private:
   int feet;             // 0 to infinite
   int inches;           // 0 to 12
   public:
   // required constructors
   Distance(){
     feet = 0;
     inches = 0;
   }
   Distance(int f, int i){
     feet = f;
     inches = i;
   }
   // method to display distance
   void displayDistance()
   {
      cout << "F: " << feet << " I:" << inches <<endl;
   }
   // overloaded minus (-) operator
   Distance operator- ()  
   {
     feet = -feet;
     inches = -inches;
     return Distance(feet, inches);
   }
   };
   int main()
   {
      Distance D1(11, 10), D2(-5, 11);

      -D1;                     // apply negation
      D1.displayDistance();    // display D1

      -D2;                     // apply negation
      D2.displayDistance();    // display D2

      return 0;
    }

如果要在operator-（）函数中返回Distance的实例，则不应该像新的Distance（英尺，英寸）那样返回。这行代码如何在这里工作？ //返回距离（英尺，英寸）;

Answer 1

如果要在operator-（）函数中返回Distance的实例，则不应该像new Distance(feet,inches)
那样返回

不，这里不需要new。只需返回一份副本。

实际上，否定运算符的实现看起来应该是

Distance operator- () const
{
    return Distance(-feet, -inches);
}

不触及当前实例成员变量（const保证）。

Answer 2

...

// overloaded minus (-) operator
    Distance &operator- ()
    {
        feet = -feet;
        inches = -inches;
        return (*this);
    }
};


int main(int argc, const char * argv[]) {

    Distance D1(11, 10), D2(-5, 11);

    D1.displayDistance();
    -D1;
    D1.displayDistance();    // apply negation and display D1

    D2.displayDistance();
    (-D2).displayDistance();    // apply negation and display D2
    (-D2).displayDistance();    // apply negation again and display D2

    return 0;
}

Answer 3

由于以下原因，它似乎有效：

在内部，变量英尺和英寸被否定，即可变值。
然后根据具体情况打印D1或D2的值。
忽略从操作员返回的对象，这是错误的。

一元运算符重载应该是：

Distance & operator- ()
{
    feet = -feet;
    inches = -inches;
    return *this;
}

运算符重载：如何在一元运算符重载函数返回中使用此代码？

3 个答案: