Question

我用这种方式声明了一个模板Matrix类：

template<typename Type> class Matrix {
   // Some code for matrix computations
}

现在，我试图以一种保证较大Type将成为结果的方式重载operator+。我正在尝试这件事：

template<typename OtherType> 
Matrix<Type> operator+ (Matrix<OtherType> mat) {
    // Dimension check and matrix addition code
}

但是这样做，我几乎会强迫C ++选择Matrix<Type>作为返回类型。我想要实现的是，例如，Matrix<int> + Matrix<float>将导致Matrix<float>。

有关如何执行此操作的任何建议吗？

Answer 1

您可以使用编译时条件：

template<
    typename OtherType,
    typename T = typename std::conditional<(sizeof(Type) <= sizeof(OtherType)),
                    OtherType, Type>::type
>
Matrix<T> operator+ (const Matrix<OtherType>& mat);

或使用C ++ 11功能decltype推断出类型：

template<typename OtherType>
auto operator+ (const Matrix<OtherType>& mat)
    -> Matrix<decltype(std::declval<OtherType>() + std::declval<Type>())>;

Answer 2

您可以在此简化示例上对此问题进行建模：

#include <type_traits>

template <typename T, typename U>
typename std::common_type<T, U>::type add(T x, U y)
{
    return x + y;
}

可替换地：

template <typename T, typename U>
auto add(T x, U y) -> decltype(x + y)
{
    return x + y;
}

这两种解决方案一般不完全相同，但应该用于基本算术运算。

Answer 3

您需要一个映射，描述应为给定的类型组合选择哪种类型。例如（刚刚为浮点类型完成;当然可以扩展）：

template <typename, typename> struct best_type;
template <typename T> struct best_type<T, T> { typedef T type; };
template <> best_type<float, double> { typdef double type; };
template <> best_type<double, float> { typdef double type; };
template <> best_type<float, long double> { typdef long double type; };
template <> best_type<long double, float> { typdef long double type; };
template <> best_type<double, long double> { typdef long double type; };
template <> best_type<long double, double> { typdef long double type; };


template <typename T0, typename T1>
Matrix<typename best_type<T0, T1>::type>
operator+ (Matrix<T0> const& m0, Matrix<T1> const& m1) {
    // ...
}

operator+()被制定为非成员，但它也可以是成员（通常，operator+()成为非成员，可能会更好地委托成员{{1} }）。

C ++中的条件模板返回类型

3 个答案: