【问题标题】:How do I solve an ambiguous operator overload issue?如何解决模棱两可的运算符重载问题?
【发布时间】:2020-06-09 13:59:32
【问题描述】:

我有一个类Fraction 定义为:

class Fraction
{
  int d_numerator;
  int d_denominator;

  Fraction(numerator, denominator)
    :
  d_numerator(numerator), d_denominator(denominator)
  {}

  Fraction(double number)
    :
  d_numerator(static_cast<int>(number * 100000)), d_denominator(100000)
  {}
};

我需要重载 operator+ 以允许我添加 2 个 Fraction 对象:

Fraction Fraction::operator+(const Fraction& other)
{
  Fraction result = Add(other); //Add() implementation omitted for brevity
  return result;
}

我有一个重载的operator(double)函数,它允许我将Fraction对象转换为double类型,例如double b = (double)a;,其中a的类型是Fraction。

Fraction::operator(double){//omitted for brevity}

我希望能够像这样将double 添加到Fraction:Fraction c = a + 2.6;

问题是这不会编译,因为有几种方法可以解释语句Fraction c = a + 2.6;的转换

我收到以下编译器错误:

错误 C2666:'Fraction::operator +':3 个重载具有相似的转换 可能是

  1. 'Fraction Fraction::operator +(const Fraction &)
  2. 或内置 C++ operator+(double, double)
  3. 或内置 C++ operator+(float, double)

我认为这个的本质是,编译器应该:

  1. 使用 operator(double) 重载将 Fraction a 转换为双精度并添加两个双精度
  2. 或者,使用允许这样做的构造函数将双精度 2.6 转换为 Fraction 并添加两个 Fractions?

有没有办法强制编译器使用另一条路线,或者任由它选择。只要结果符合预期,我不介意。

谢谢

【问题讨论】:

  • 我建议制作一个采用double 的构造函数,一个explicit 构造函数。无论如何,这可能是个好主意。
  • const 丢失,另外将operator+ 定义为成员函数会影响重载决议。
  • 你能分享一个完整的例子吗? Fraction::operator(double) 看起来很奇怪,我不知道那是什么意思。
  • 构造函数Fraction(numerator, denominator)不会也报错吗?
  • 隐式转换通常并不是一个好主意,因为它们最初看起来并不那么好。 (例如:C++。)

标签: c++ operator-overloading


【解决方案1】:

我希望能够像这样向 Fraction 添加双精度:Fraction c = a + 2.6;

问题是这不会编译,因为有几种方法可以解释语句 Fraction c = a + 2.6 的转换;

您有一个隐式转换运算符(从Fraction 到double)和一个隐式转换构造函数(从double 到Fraction),两者都导致operator+ 的有效匹配,编译器拒绝继续这种模棱两可的说法。

建议进行explicit 的转换,但如果您真的希望Fraction c = a + 2.6 起作用,您可以将到 double 的转换设为显式。这意味着如果您想将 a 转换为 double,则必须使用 static_cast&lt;double&gt;(a)。

我已经做了一个工作示例,用于在代码中添加两个带有 cmets 的 Fractions。使用其他运算符扩展它作为练习。

#include <iostream>

class Fraction {
public:
    Fraction(int numerator, int denominator) :
        d_numerator(numerator), d_denominator(denominator) 
    {}

    // a converting constructor for double
    Fraction(double number) :
        d_numerator(static_cast<int>(number * 1000000)), d_denominator(1000000)
    {}

    // add a Fraction to *this
    Fraction& operator+=(const Fraction& o) {
        d_numerator = d_numerator * o.d_denominator + o.d_numerator * d_denominator;
        d_denominator *= o.d_denominator;
        return *this;
    }

    // explicit conversion to double
    explicit operator double() const {
        return static_cast<double>(d_numerator) / d_denominator;
    }

private:
    int d_numerator;
    int d_denominator;
};

// A free function to add two Fractions - take the left hand side by value
// and you can return the same object (after having added the right hand side to it).
Fraction operator+(Fraction a, const Fraction& b) {
    // use the member operator+=
    return a += b;
}

Full demo

在演示中,我使用了 C++17 函数 std::gcd,因为在处理分数时数字越小越好,并且它具有流式传输以支持打印。

【讨论】:

  • 虽然代码不错,但还有很多没有很好解释的地方,比如问题的答案。还有一个与问题无关的大量,例如explicit Fraction(int number) 构造函数和norm。考虑链接到完整代码,而不是发布完整代码作为答案。
  • @MooingDuck 那里...我想我已经删除了所有非必要的东西并把它放在演示中。
猜你喜欢
  • 1970-01-01
  • 1970-01-01
  • 1970-01-01
  • 2010-12-10
  • 1970-01-01
  • 2013-11-18
  • 1970-01-01
  • 2012-12-08
  • 2014-09-26
相关资源
最近更新 更多