C++ C++；两个双精度的重载运算符%

是否有可能使操作员%过载两倍

const double operator%(const double& lhs, const double& rhs)
{
    return fmod(lhs, rhs);
}

当然，这会产生错误，因为两个参数中的一个必须具有类类型。 所以我想利用C++的隐式构造函数调用的可能性来解决这个问题。我是这样做的：

class MyDouble {
public:
    MyDouble(double val) : val_(val) {}
    ~MyDouble() {}

    double val() const { return val_; }

private:
    double val_;
};


const double operator%(const MyDouble& lhs, const double& rhs)
{
    return fmod(lhs.val(), rhs);
}

const double operator%(const double& lhs, const MyDouble& rhs)
{
    return fmod(lhs, rhs.val());
}

。。。以及：

double a = 15.3;
double b = 6.7;

double res = a % b; // hopefully calling operator%(const MyDouble&, const double) using a implicit constructor call

不幸的是，这不起作用！任何提示、想法。。。非常感谢！ 提前感谢,，

---

Jonas

这不起作用的原因是，只有当表达式的至少一个操作数具有类或枚举类型时，才会触发用户定义运算符函数的重载解析

所以你运气不好。这行不通

---

我认为最好的方法是等待C++0x编译器，而不是编写

3.14

，而是将

3.14_myd

作为用户定义的文本编写

或者，实现

double MyDouble:：operator%（constdouble&）const，如下所示：

#include <iostream>
#include <cmath>

class t_double {
public:
    t_double(const double& val) : d_val(val) {
    }

    t_double(const t_double& other) : d_val(other.d_val) {
    }

    ~t_double() {
    }

    const double& val() const {
        return this->d_val;
    }

    double operator%(const double& rhs) const {
        return fmod(this->val(), rhs);
    }

    double operator%(const t_double& rhs) const {
        return fmod(this->val(), rhs.val());
    }

private:
    double d_val;
};

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

    const t_double a(15.3);
    const t_double b(6.7);

    std::cout << a % b << " == " << a.val() << " % " << b.val() << "\n";

    return 0;
}

#包括
#包括
双级{
公众：
t_-double（const-double&val）：d_-val（val）{
}
t_double（const t_double&other）：d_val（other.d_val）{
}
~t_double（）{
}
常量double&val（）常量{
返回此->d_val；
}
双运算符%（常数双和rhs）常数{
返回fmod（此->val（），rhs）；
}
双运算符%（常数t_双和rhs）常数{
返回fmod（this->val（），rhs.val（））；
}
私人：
双d_val；
};
int main（int argc，char*const argv[]{
康斯特双a（15.3）；
常数双b（6.7）；
std：：我可以这样想，但我没有成功：（举个小例子，我会很高兴的！谢谢！好的，但是如果你把常数t_double a（15.3）；改为double a=15.3；（对于b），则代码将不会编译。在代码中，我想使用的不是t_double而是double。它不会编译，因为您必须声明自由函数：
double运算符%（const double&lhs，const t_double&rhs）{返回t_double（lhs）%rhs；}
我原以为你说过
double a；t\u double b；a%b
没有编译。不，我想要的是：double a=14.3；double b=11.23；double c=a%b；嗯……为什么不直接调用
fmod（）
而不是在不必要的地方使用操作符重载呢？