Question

我有一个我正在重载operator+的模板类，但需要它可能返回与实例化类不同的数据类型。例如，以下片段执行vector * vector（内积），vector * scalar或scalar * vector的标准数学定义。具体来说，假设我有一个Vector<int>，标量是double类型 - 我想从“vector * scalar”operator+函数返回一个双精度。

我很确定我错过了朋友函数（？）的一些template<class T>语句，但这段代码并不打算编译。

template<class T>
class Vector
{
private:
    std::vector<T> base;

public:
    friend Vector operator*(const Vector& lhs, const Vector& rhs);  // inner product    
    Vector<T> operator*(const T scalar);  // vector*scalar   
    friend Vector operator*(const T scalar, const Vector& rhs);  // scalar*vector
};

template<class T>
Vector<T> operator*(const Vector<T>& lhs, const Vector<T>& rhs)  // inner product
{
    assert( lhs.base.size() == rhs.base.size() );

    Vector result;
    result.base.reserve(lhs.base.size());
    std::transform( lhs.base.begin(), lhs.base.end(), rhs.base.begin(), std::back_inserter(result.base), std::multiplies<T>() );

    return result;
}

template<class T>
Vector<T> Vector<T>::operator*(const T scalar)  // vector*scalar
{
    Vector result;
    result.base.reserve(base.size());

    std::transform( base.begin(), base.end(), std::back_inserter(result.base), std::bind1st(std::multiplies<T>(), scalar) );

    return result;
}

template<class T>
Vector<T> operator*(const T scalar, const Vector<T>& rhs)  // scalar*vector
{
    Vector result;
    result.base.reserve(rhs.base.size());

    std::transform( rhs.base.begin(), rhs.base.end(), std::back_inserter(result.base), std::bind1st(std::multiplies<T>(), scalar) );

    return result;
}

Answer 1

朋友声明应如下所示：

template<class S>
class Vector
{
private:
    std::vector<S> base;

public:
    template<class T> friend T operator*(const Vector<T>& lhs, const Vector<T>& rhs);  // inner product    
    template<class T> friend Vector<T> operator*(const T scalar);  // vector*scalar   
    template<class T> friend Vector<T> operator*(const T scalar, const Vector<T>& rhs);  // scalar*vector
};

其余代码如下：

template<class T>
T operator*(const Vector<T>& lhs, const Vector<T>& rhs)  // inner product
{
    assert( lhs.base.size() == rhs.base.size() );

    Vector<T> result;
    result.base.reserve(lhs.base.size());
    std::transform( lhs.base.begin(), lhs.base.end(), rhs.base.begin(), std::back_inserter(result.base), std::multiplies<T>() );

    return result;
}

template<class T>
Vector<T> operator*(const Vector<T>& lhs, const T scalar)  // vector*scalar
{
    return scalar*lhs;
}

template<class T>
Vector<T> operator*(const T scalar, const Vector<T>& rhs)  // scalar*vector
{
    Vector<T> result;
    result.base.reserve(rhs.base.size());

    std::transform( rhs.base.begin(), rhs.base.end(), std::back_inserter(result.base), std::bind1st(std::multiplies<T>(), scalar) );

    return result;
}

Answer 2

我想你想要的是返回一个Vector类型值为每个组件操作返回的类型，它不一定是标量的类型。

例如：

Vector<int>    * int    -> Vector<int>
Vector<int>    * double -> Vector<double>
Vector<double> * int    -> Vector<double>
Vector<char>   * float  -> Vector<float>

等

为此，您应该分别定义两种输入类型，例如T1和T2（并且其中一个或两个操作数是Vector。您不希望简单地使用标量类型（对于矢量*标量或标量*向量运算）作为结果，否则它可能会被转换（请参阅我的第3个示例：结果将为Vector<int>。< / p>

可以使用decltype来查找第三种（结果）类型。

为简单起见，将运算符定义为非成员：

template<typename T1, typename T2, typename T3 = decltype(std::declval<T1>() * std::declval<T2>())>
Vector<T3> operator*(const Vector<T1>& lhs, const T2 & scalar)  // inner product
{
    Vector<T3> result;
    //...
    return result;
}

有趣的部分是

T3 = decltype(std::declval<T1>() * std::declval<T2>())

在这里，我们使用其他两种类型T3和T1找到类型T2。首先，我们构造两个具有不重要值的值（std::declval函数是一个辅助函数，返回给定为模板参数的类型）。然后我们将这些值相乘，但结果再次不重要;我们只对这种类型感兴趣。这就是第三部分的作用：decltype为您提供表达式的类型（不进行评估）。

其他运营商可以类似地实施。

为了让这些运营商成为朋友，你需要语法

template<...> friend ...

见Danvil's answer。

Answer 3

您可以添加更多模板参数：

template<class T, class S>
Vector<S> Vector<T>::operator*(const S scalar)

并确保在标量类型中使用S，在函数体中的正确位置使用T作为向量元素类型。

模板类自动类型转换的运算符重载

3 个答案: