c++ - 派生类的重载解析失败

Question

我正在使用 mArray 类，它实现了具有可变维度的数值数据容器

template <typename T>
   class mArray<T>: {
     ...
     std::vector<T> my_data;
   }

另一类mImage继承自 mArray并提供特定于图像的操作，以及另一个类 mDcmImage继承自 mImage并提供特定于格式的功能。

我认为这是一种分离不同类型功能的非常简洁的方法。

一个例子或mArray功能:逐元素添加:

// add a mArray to the data [1]
template <typename U>
void operator+= (const mArray<U>& other) {
    if (other.getSizes() != getSizes())
        throw std::invalid_argument {"incompatible sizes"};
    else {
        std::transform (my_data.begin(),
                        my_data.end(),
                        my_data.begin(),
                        my_data.begin(),
                        []( const T &a, const U &b) { return a+b; } );
    }
    return;
}

// add an element to the data [2]
template <typename U>
void operator+= (const U& rhs) {
    assert (!std::is_arithmetic<U>::value);
    std::transform (my_data.begin(),
                    my_data.end(),
                    my_data.begin(),
                    [&rhs]( const T &lhs) { return lhs+rhs; } );
    return;
}

(getSizes() 是一个mArray 函数)
但是现在我的代码加载了 mDcmImage<int>来自一个文件，当我使用

typedef int intensity;
mDcmImage<intensity> im1 ("/tmp/test1.im");
mDcmImage<intensity> im2 ("/tmp/test2.im");
im1 += im2;

然后我得到以下错误:

mArray.hpp required from ‘struct mArray<T>::operator+=(const U&) 
           [with U = mDcmImage<int>; T = int]::<lambda(const int&)>’|
mArray.hpp required from ‘void mArray<T>::operator+=(const U&) 
           [with U = mDcmImage<int>; T = int]’|
  test.cpp required from here|
mArray.hpp error: no match for ‘operator+’ in ‘lhs + rhs’|

换句话说:虽然我编写了另外一个 mArray 的代码以及添加一个值，当我调用 += 时主程序中的运算符将两个数组相加，它使用 +=单个值的实现。

我试过几种方法，比如

• 使用std::enable_if<std::is_arithmetic<U>::value >::type*对于 operator+= 的值版本-- 不允许，因为 operator+=严格采用 1 个参数
• 定义 operator+= 的两个版本对于 mImage和 mDcmImage同样——在这些级别上，它也使用了错误的实现。

在 simplified example 中选择了正确版本的运算符 -- 为什么不现在呢？我不明白为什么重载决议在这里失败了。

Answer 1

模板参数推导后，第二个版本成为完美匹配:

template <typename U> void operator+= (const U& rhs); // U = mDcmImage<int>

与需要从 mDcmImage 转换为 mArray 的第一个版本相比:

template <typename U> void operator+= (const mArray<U>& other); // U = int

所以它是由重载决策选择的。

---

最简单的修复可能是修改单值版本以仅采用 T 并依赖隐式转换:

void operator+= (const T& rhs);

SFINAE 也是可能的，例如在返回类型中:

template <typename U> 
typename std::enable_if<std::is_arithmetic<U>::value>::type operator+= (const U& rhs);