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

Question

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

我很确定我缺少一些用于友元函数的 template<class T> 语句（？），但这个 sn-p 并不意味着编译。

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

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

例如：

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

等等

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

以上可以使用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>())

在这里，我们使用其他两个类型 T1 和 T2 找到类型 T3。首先，我们构造两个值不重要的值（std::declval 函数是一个帮助函数，返回作为模板参数给出的类型）。然后我们将这些值相乘，但结果还是不重要的；我们只对类型感兴趣。这就是第三部分的作用：decltype 为您提供表达式的类型（不计算它）。

其他运算符可以类似地实现。

为了使这些运算符成为朋友，您需要语法

template<...> friend ...

如在Danvil's answer 中看到的那样。

Answer 2

朋友声明应该是这样的：

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 3

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

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

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