Question

我有一个模板类，通常由<double>实例化。

我的标题有：

template <typename T> class F;
// Non-member functions
template <typename T> const F<T> operator*(F<T> lhs, const F<T>& rhs);
template <typename T> const F<T> operator*(const F<T>& lhs, const T& rhs);

template <typename T>
class F
{
    // blah blah
    F<T>& operator*=(const F<T>& rhs);
    F<T>& operator*=(const T& rhs_scalar);
    // blah
    friend const F<T> operator*(const F<T>& lhs, const T& rhs) { return F(lhs) *= rhs; }
    friend const F<T> operator*(const T& lhs, const F<T>& rhs) { return F(rhs) *= lhs; }
};

在我的.cpp文件中，我有类似的内容：

#include "F.H"

// lots of template<typename T> returntype F<T>::function(args){ body }
template <typename T>
F<T>& F<T>::operator*=(const F<T>& rhs)
{
    // check sizes, etc
    // do multiplication
    return *this;
}
template <typename T>
F<T>& F<T>::operator*=(const T& rhs_scalar)
{
    for(auto &lhs : field_) // field_ is a vector holding values
    {
         lhs *= rhs_scalar;
    }
    return *this;
}

// Non-member parts
template <typename T> operator*(F<T> lhs, const F<T>& rhs)
{ lhs *= rhs; return lhs; }
template <typename T> operator*(const F<T>& lhs, const T& rhs)
{ return F<T>(lhs) *= rhs; }

template class F<double>;
template const F<double> operator*<double>(F<double>, const F<double>&);

这编译并运行正常，并允许以下内容：

F<double> test(..);
test *= 2.5; test *= 10; test /= 2.5; test /= 10; // and so on

我的问题是：我是否可以减少运营商的声明和定义数量，同时保留隐含地将int推广到double等的能力？我可以重新排列代码，以便在头文件之外定义friend .. operator*(..)实体吗？（我怀疑这会在头文件和cpp文件中的一个或两个中涉及更具体的实例化）

（旁注：如何？Scott Meyer在'Effective C ++'中的第46项描述了隐式参数转换，但似乎描述了允许构造临时对象（在这种情况下）Rational(int) * Rational_object_already_created;）< / p>

Answer 1

我是否可以减少运营商的声明和定义数量，同时保留隐含地将int推广到double等的能力？

您可以通过提供转换构造函数来实现。

template <typename T2>
   F(F<T2> const& f2 ) {...}

在模板运算符*＆lt;＆gt;中将int隐式转换为double

1 个答案: