模板类内模板函数重载问题：矩阵加法编译错误求解

问题背景 #

我正在编写一个支持多种数据类型的模板矩阵类，类定义片段如下：

template <typename T>
class Matrix
{
private:
    size_t rows;
    size_t cols;
    std::shared_ptr<T[]> data;

需要实现支持矩阵-矩阵加法和矩阵-常量加法的operator+运算符重载函数，实现代码如下：

template <typename T>
Matrix<T> Matrix<T>::operator+(const Matrix<T> &other) const{
    size_t length = this->cols * this->rows;

    for (size_t i = 0; i < length; ++i)
    {
        result.data[i] = this->data[i] + other.data[i];
    }
}

template <typename T>
template <typename U>
Matrix<T> Matrix<T>::operator+(U num){
    size_t length = this->cols * this->rows;

    for (size_t i = 0; i < length; ++i)
    {
        result.data[i] = this->data[i] + num;
    }
}

执行矩阵-矩阵加法操作时，编译器无法区分这两个重载函数，报错信息如下：

测试代码 #

WellsMatrixLib::Matrix<double> a(5,5);
WellsMatrixLib::Matrix<double> b(5,5);
a.fill(5);
b.fill(6);
std::cout << a(1,1) << std::endl;
WellsMatrixLib::Matrix<double> c = a + b;

错误信息 #

In file included from main.cpp:1:
matrix.cpp: In instantiation of ‘WellsMatrixLib::Matrix<T> WellsMatrixLib::Matrix<T>::operator+(U) [with U = WellsMatrixLib::Matrix<double>; T = double]’:
main.cpp:8:44:   required from here
matrix.cpp:168:28: error: cannot convert ‘WellsMatrixLib::Matrix<double>’ to ‘std::__shared_ptr_access<double [], __gnu_cxx::_S_atomic, true, false>::element_type’ {aka ‘double’} in assignment
  168 |             result.data[i] = this->data[i] + num;
      |             ~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~

请问除了将模板参数U改为T之外，还有什么其他解决办法？

解决办法 #

1. 给模板版本的operator+添加SFINAE约束 #

通过std::enable_if限制模板参数U不能是Matrix<T>类型，同时确保U可以和T进行加法运算：

#include <type_traits>

template <typename T>
template <typename U>
typename std::enable_if<
    !std::is_same<U, Matrix<T>>::value &&
    std::is_convertible<decltype(std::declval<T>() + std::declval<U>()), T>::value,
    Matrix<T>
>::type
Matrix<T>::operator+(U num){
    Matrix<T> result(this->rows, this->cols); // 先初始化result
    size_t length = this->cols * this->rows;

    for (size_t i = 0; i < length; ++i)
    {
        result.data[i] = this->data[i] + num;
    }
    return result;
}

编译器遇到矩阵-矩阵加法时，会优先匹配非模板的operator+(const Matrix<T>&)，模板版本仅在U是可与T相加的非矩阵类型时被启用。

2. 将矩阵-常量加法实现为全局友元函数 #

把常量加法的重载移到类外部作为全局友元，既避免成员函数重载的二义性，还支持num + matrix的操作：

// 类内部声明友元
template <typename T>
class Matrix
{
    // ... 其他成员 ...
public:
    Matrix<T> operator+(const Matrix<T>& other) const;

    template <typename U>
    friend Matrix<T> operator+(const Matrix<T>& mat, U num);

    template <typename U>
    friend Matrix<T> operator+(U num, const Matrix<T>& mat);
};

// 实现矩阵-矩阵加法成员函数
template <typename T>
Matrix<T> Matrix<T>::operator+(const Matrix<T>& other) const{
    Matrix<T> result(this->rows, this->cols);
    size_t length = this->cols * this->rows;
    for (size_t i = 0; i < length; ++i)
    {
        result.data[i] = this->data[i] + other.data[i];
    }
    return result;
}

// 实现矩阵-常量加法全局函数
template <typename T, typename U>
Matrix<T> operator+(const Matrix<T>& mat, U num){
    Matrix<T> result(mat.rows, mat.cols);
    size_t length = mat.cols * mat.rows;
    for (size_t i = 0; i < length; ++i)
    {
        result.data[i] = mat.data[i] + num;
    }
    return result;
}

// 实现常量-矩阵加法全局函数
template <typename T, typename U>
Matrix<T> operator+(U num, const Matrix<T>& mat){
    return mat + num; // 复用上面的实现
}

全局函数的重载优先级低于成员函数的非模板版本，矩阵相加会优先匹配成员函数，常量相加则匹配全局模板函数。

3. 使用标签分发（Tag Dispatch） #

定义标签类型，通过标签区分不同加法逻辑，适合复杂场景：

namespace detail {
    struct MatrixTag {};
    struct ScalarTag {};

    template <typename T>
    Matrix<T> add_impl(const Matrix<T>& lhs, const Matrix<T>& rhs, MatrixTag){
        Matrix<T> result(lhs.rows, lhs.cols);
        size_t length = lhs.cols * lhs.rows;
        for (size_t i = 0; i < length; ++i)
        {
            result.data[i] = lhs.data[i] + rhs.data[i];
        }
        return result;
    }

    template <typename T, typename U>
    Matrix<T> add_impl(const Matrix<T>& lhs, U num, ScalarTag){
        Matrix<T> result(lhs.rows, lhs.cols);
        size_t length = lhs.cols * lhs.rows;
        for (size_t i = 0; i < length; ++i)
        {
            result.data[i] = lhs.data[i] + num;
        }
        return result;
    }
}

template <typename T>
Matrix<T> Matrix<T>::operator+(const Matrix<T>& other) const{
    return detail::add_impl(*this, other, detail::MatrixTag{});
}

template <typename T>
template <typename U>
Matrix<T> Matrix<T>::operator+(U num){
    return detail::add_impl(*this, num, detail::ScalarTag{});
}

通过传递不同标签，让编译器明确选择对应实现逻辑，避免二义性。

内容的提问来源于stack exchange，提问作者Wells