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

Question

我有一个要为其重载的模板类 operator+ ，但需要它可能返回不同于实例化类的数据类型。例如，以下代码片段执行 vector * vector (内积)、 vector *标量或标量* vector 的标准数学定义。具体来说，假设我有一个 Vector<int>标量的类型为 double -- 我想从“vector*scalar”中返回一个 double 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

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

例如:

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

等等

为此，您应该分别定义两种输入类型，比方说T1和 T2 (一个或两个操作数是它的 Vector)。您不想简单地使用标量类型(对于 vector * 标量，或标量 * 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>())

在这里，我们找到类型 T3使用其他两种类型 T1和 T2 .首先，我们构造两个不重要的值(std::declval 函数是一个辅助函数，返回作为模板参数给定的类型)。然后我们将这些值相乘，但结果同样不重要；我们只对类型感兴趣。这就是第三部分所做的:decltype为您提供表达式的类型(不对其求值)。

其他算子可以类似实现。

为了让那些运算符成为 friend ，你需要语法

template<...> friend ...

见 Danvil's answer .