Question

我正在尝试为4种情况实现乘法运算符（operator*）。

想象一下，我有class rain。

namespace manchester {

    namespace manchester_private_dont_use_this {

        template<typename T>
        class rain
        {

        public:
            rain(T initial_rain)
                : m_rain(initial_rain)
            {
            }

        private:
             T m_quantity_of_rain;
        };

    }

} //namespace manchester

假设此类在私有命名空间内声明。 typedef rain<float> rainf;和typedef rain<double> raind在非私有命名空间中公开此类的功能。私有命名空间是指另一个嵌套命名空间，称为namespace rainprivate_do_not_use_me。（在示例中，我实际上添加了两个名称空间来解释我正在谈论的内容，但这并不重要。）这是我能想出的最好的，以防止最终用户（我）尝试创建{{1}这是没有多大意义的，因为雨以升为单位测量，因此我们可以得到非整数量。

无论如何，我就像我说的那样实施rain<int>，以便将operator*和float的雨量相乘。我是否正确假设因为这些类型可以隐式转换，我只需要实现一个运算符，其中rhs变量是double，而lhs变量是double。（通过加倍我实际上是指类型，T。）

再一次，我在这里猜测 - 看看我之前关于一元运算符的问题，但我猜是这样的:(我再也找不到任何关于SO的信息来回答我的问题。）

double

同样，我不确定所以认为可能更好的问题而不是学习错误。我想到的4个情况是上面两个，然后两个隐藏的情况，// friend function: inline rain<T> operator*(const rain<T>& _rain, const T _t) { return rain<T>(_rain.m_quantity_of_rain * _t); } inline rain<T> operator*(const T _t, const rain<T>& _rain) { return rain<T>(_rain.m_quantity_of_rain * _t); }可以转换为双float T in the case when double`，反之亦然。

Answer 1

你可以直接使用double，让隐式转换执行任务，但请注意，由于float的大小小于double，这可能会导致数据丢失。

inline rain<T> operator*(const rain<T>& _rain, const double _t)
{
    return rain<T>(_rain.m_quantity_of_rain * _t);
}

inline rain<T> operator*(const double _t, const rain<T>& _rain)
{
    return rain<T>(_rain.m_quantity_of_rain * _t);
}

还试图避免特定模板实例化，例如rain<int>，当有人试图这样做时，你可能会抛出编译错误。请参阅此处：How to intentionally cause a compile-time error on template instantiation

C ++运算符重载：用户定义类型乘以浮点值

1 个答案: