C++ 重载加法运算符时的代码重复

让我们以一个表示区间的简单类为例。我希望它支持以下操作：

int main()
{
    Interval<double> i1(1, 2);
    Interval<double> i2(3, 4);

    i1   + 1.0;
    1.0  + i1;
    i1   + 1.0f;
    1.0f + i1;
    i1   + 1;
    1    + i1;
    i1   + i2;
}

intmain（）
{
区间i1（1,2）；
间隔i2（3,4）；
i1+1.0；
1.0+i1；
i1+1.0f；
1.0f+i1；
i1+1；
1+i1；
i1+i2；
}

一个可能的实现是

template<typename Real>
class Interval
{
public:
    Interval(Real value)
        : lower(value), upper(value)
    { }

    template<typename Real2>
    Interval(Real2 value)
        : lower(value), upper(value)
    { }

    template<typename Real2>
    Interval(Real2 l, Real2 u)
        : lower(l), upper(u)
    { }

    Interval<Real>& operator += (Interval<Real> rhs)
    {
        lower += rhs.lower;
        upper += rhs.upper;
        return *this;
    }

private:
    Real lower, upper;
};

template<typename Real>
const Interval<Real> operator + (Interval<Real> i1, const Interval<Real>& i2)
{
    i1 += i2;
    return i1;
}

template<typename Real1, typename Real2>
const Interval<Real1> operator + (Interval<Real1> i1, const Real2& r2)
{
    i1 += r2;
    return i1;
}

template<typename Real1, typename Real2>
const Interval<Real2> operator + (const Real1& r1, Interval<Real2> i2)
{
    i2 += r1;
    return i2;
}

模板
课间休息
{
公众：
间隔（实际值）
：下限（值）、上限（值）
{ }
模板
间隔（Real2值）
：下限（值）、上限（值）
{ }
模板
间隔（Real2 l，Real2 u）
：下部（l）、上部（u）
{ }
间隔和运算符+=（间隔rhs）
{
较低+=右侧较低；
上部+=右侧上部；
归还*这个；
}
私人：
真正的低，上；
};
模板
常量间隔运算符+（间隔i1、常量间隔和i2）
{
i1+=i2；
返回i1；
}
模板
常量区间运算符+（区间i1、常量实数2和r2）
{
i1+=r2；
返回i1；
}
模板
常量间隔运算符+（常量实数1和r1，间隔i2）
{
i2+=r1；
返回i2；
}

这有一些代码重复。是否有更“经济”的实施方案？最佳做法是什么？

通过在

Interval

中提供只接受一个

Real

类型的参数的构造函数，可以最小化重载函数的数量

那么，您需要实现的就是：

template <typename Real>
Interval<Real> operator+(Interval<Real> const& lhs, Interval<Real> const& rhs)

模板
间隔运算符+（间隔常数和左侧、间隔常数和右侧）

更新

如果我有一个成员函数：

Interval operator + (const Interval& i2)
{
   Interval<Real> i1 = *this; 
   i1 += i2;
   return i1;
}

template<typename Real>
Interval<Real> operator + (Interval<Real> i1, const Interval<Real>& i2)
{
    i1 += i2;
    return i1;
}

Interval操作符+（常量Interval&i2）
{
区间i1=*此；
i1+=i2；
返回i1；
}

然后，我能够编译：

Interval<double> i1(1, 2);
Interval<double> i2(3, 4);

std::cout << (i1 + i2) << std::endl;

std::cout << (i1 + 1.0) << std::endl;
std::cout << (i1 + 1.0f) << std::endl;
std::cout << (i1 + 1) << std::endl;

区间i1（1,2）；
间隔i2（3,4）；
不能，我不应该。但我正在修改一个临时副本。在这种情况下，您可能可以依赖构造函数定义的隐式转换…您想要避免的代码重复是什么意思？请注意，。哦，嘿，我们开始了：我做了一件荒谬的事！你确定吗？一开始我也这么想。但是，我无法在Visual Studio 2013中实现这一点。我的示例程序是否编译？成员函数的行为与所描述的不同：@MooingDuck，我认为
（1.0+i1）
与成员函数完全不兼容。我对
（i1+1.0）
与成员函数一起工作而与自由函数不一起工作感到困惑。啊哈，明白了！作为一个成员函数，没有模板推导，因此转换就开始发挥作用。作为一个自由函数，有一个模板演绎，它不允许用户转换。@Petter:经过多次尝试和错误后：是的。到目前为止，我的最佳表现与您开始时的几乎相同：
std::cout << (i1 + 1.0) << std::endl;
std::cout << (i1 + 1.0f) << std::endl;
std::cout << (i1 + 1) << std::endl;