1

我正在为我的项目做一个小理性类，我重载了所有的算术运算符。好吧，当我尝试重载 operator= 时，我有一点点，现在我不知道是我的问题（我不知道它是如何工作的）还是我的 writen 代码的问题（我写得不好），这是代码：

class rational{

   public:
      double& operator=(double& d){
         d= this->num/this->den;
         return d;
      }
      double& operator=(rational& r){
            double d= r.num/r.den;
            return d;
      }
      double& operator=(){
            double d= this->num/this->den;
            return d;
      }
}

好的，怎么了？什么是对的？（我认为一切都错了哈哈）

我的目标是这样做：

int main(){
    rational r(4, 5);
    double d= r;
}

我可以做吗？如果是，如何？

4

2 回答 2

3

您不需要为此目的使用赋值运算符 - 您应该重载转换运算符；例如

class rational {
  private: 
    int num;
    int den; 

  public: 
    // ... 
    operator double() { return double(num) / double(den); }
};

这将允许

rational r(4, 5);
double d = double(r); // d = 0.8

如果您希望允许，则应使用赋值运算符来更改现有对象的状态。您可能不想允许将 double 分配给有理数，这样的操作没有明确的含义。但是，您可能希望提供用于分配 int 的帮助器，例如，除了通常用于分配另一个有理数的帮助器：

rational &operator=(const rational &rhs)
{
    num = rhs.num;
    den = rhs.den;
    return *this;
}

rational &operator=(int rhs)
{
    num = rhs;
    den = 1;
    return *this;
}
于 2013-08-16T04:33:39.833 回答
2

在这里我认为用户定义的转换operator会更合适。

class rational {
public: 
    rational( int iNum, int iDen ) : num( iNum ), den( iDen ) {}

    // ... 
    operator double() { return (double)num / (double)den; }

private: 
    int num;
    int den;
};

int main()
{
    rational r( 1, 2 );
    double n = r;

    std::cout << r << std::endl; // output 0.5
    return 0;
}

这是一个小例子来说明这一点：http: //ideone.com/I0Oj66

关于复制分配operator=：

类的复制赋值运算符T是一个非模板非静态成员函数，其名称operator=只接受一个类型的参数T。

operator=用于更改现有对象。

例如，您可以使用它来复制另一个对象的状态：

rational &operator=( const rational &rhs )
{
    num = rhs.num;
    den = rhs.den;
    return *this;
}
于 2013-08-16T05:42:45.383 回答