Question

如何以这种方式修改以下代码，我不需要在main函数中重复f2=11; f3=12;。该代码用于重载最常见的运算符。

class FLOAT{
    private:
        float x;
    public:
        FLOAT(){    x=0.0;  }
        void setFloat(float f)      {   x=f;    }
        float getFloat()            {   return x;};
        FLOAT operator+(FLOAT obj)  {x=x+obj.x; return *this;};
        FLOAT operator-(FLOAT obj)  {x=x-obj.x; return *this;};
        FLOAT operator*(FLOAT obj)  {x=x*obj.x; return *this;};
        FLOAT operator/(FLOAT obj)  {x=x/obj.x; return *this;};
        FLOAT& operator=(const FLOAT& obj)  {this->x=obj.x; return *this;   };
        FLOAT& operator=(const float& y)    {this->x=y; return *this;   };
};

int main() {
    FLOAT f,f2,f3;
    f2=11;
    f3=12;

    f=f3-f2;
    cout<<"f3-f2 ="<<f.getFloat()<<endl;


    f2=11;
    f3=12;
    f=f3+f2;
    cout<<"f3+f2 ="<<f.getFloat()<<endl;

    f2=11;
    f3=12;
    f=f3*f2;
    cout<<"f3*f2 ="<<f.getFloat()<<endl;

    f2=11;
    f3=12;
    f=f3/f2;
    cout<<"f3/f2 ="<<f.getFloat()<<endl;

    system("pause"); // to pause console screen
    return 0;
}

Answer 1

@ Oli的答案几乎说明了为了使你的代码有效，你需要做什么 minimal 。但是，我看到（我甚至知道@Oli看到）你的类的实现有很多缺陷。

由于您已实施FLOAT，我向您解释Double的实施（FLOAT的实施方式类似）。

class Double {
  double data;
public:
  Double (double p=0.0) : data(p){}
  double value() { return data; }
  Double & operator+=(Double const & other) 
  {
         data += other.data; 
         return *this;
  }
  Double & operator-=(Double const & other) 
  {
         data -= other.data; 
         return *this;
  }
  //...
};

请注意，您无需实施operator=(Double const&)和Double(Double const&)。编译器生成的就足够了。由于构造函数采用类型double的一个参数，因此您也不需要实现operator=(double const &)。编译器生成的复制语义以及构造函数将负责这一点。

现在看看，

//implement operator+ and operator- as non-member functions
Double operator+(Double a,  Double const & b)
{
    a += b; //a is local copy, so we can change it
    return a;
}
Double operator-(Double a,  Double const & b)
{
    a -= b; //a is local copy, so we can change it
    return a;
}

请注意，我已分别按operator+和operator-实施operator+=和operator-=。

同样，您可以将operator/=和operator*=实现为成员函数，然后根据它们实现operator/和operator*！

Answer 2

您的运营商应该创建一个新实例;他们不应该自己修改（事实上，他们应该被宣布为const以防止这种情况。）

e.g：

FLOAT operator+(FLOAT obj) const
{
    FLOAT tmp;
    tmp.setFloat(x + obj.x);
    return tmp;
}

请注意，有更多惯用的方法来定义运算符重载（例如，根据operator+定义operator+=，并定义采用float的构造函数。但是上面应该足够了。

重载运算符以使用类对象？

2 个答案: