0

链接到mcve。

我们将矩阵定义为可按行和按列迭代。下面是逐行迭代器的实现：

template<class Real>
class RowIterator {
public:
    RowIterator() { }
    RowIterator(Real* begin, size_t rows, size_t cols) : begin(begin), rows(rows), cols(cols) { }

    Real* operator*() const { return begin; }
    Real& operator[](size_t col) const { return begin[col]; }

    bool operator!=(const RowIterator& it) const { return begin != it.begin; }
    RowIterator& operator++() { begin += cols; --rows; return *this; }

private:
    Real* begin;
    size_t rows, cols;
};

遍历我们的矩阵是使用Range如下定义的对象实现的：

namespace details
{

template<class Iterator>
struct Range {
    Iterator begin, end;
    Range() { }
    Range(Iterator begin, Iterator end) : begin(begin), end(end) { }
};

template<class Iterator>
Iterator begin(const Range<Iterator>& range) { return range.begin; }
template<class Iterator>
Iterator end(const Range<Iterator>& range) { return range.end; }

}

using details::Range;
template<class Iterator>
Range<Iterator> make_range(Iterator begin, Iterator end) { return Range<Iterator>(begin, end); }

这基本上是我们的使用代码：

Range<RowIterator<float>> make_row_range(float* mat, size_t rows, size_t cols) {
    return make_range(
        RowIterator<float>(mat, rows, cols),
        RowIterator<float>(mat + rows * cols, 0, cols));
}

int main() {
    size_t rows = 4, cols = 6;
    float* mat = new float[rows * cols];
    for(size_t i = 0; i < rows * cols; ++i)
        mat[i] = (float)i;
    auto rowrange = make_row_range(mat, rows, cols);

    // this loop works as expected
    std::cout << "begin, end" << std::endl;
    for(auto b = begin(rowrange), e = end(rowrange); b != e; ++b) {
        // using RowIterator<T>::operator[](size_t)
        std::cout << "start of row: " << b[0] << std::endl;
    }

    // this loop produces confusing compiler errors
    std::cout << "range based" << std::endl;
    for(auto row : rowrange) {                        // this is line 42
        // row is of type float*
        std::cout << "start of row: " << row[0] << std::endl;
    }
    return 0;
}

我编译了上面的 MCVE 并得到了以下编译器错误：

  • Visual Studio 2013（全部在第 42 行）：

    error C2064: term does not evaluate to a function taking 0 arguments
error C3536: '$S2': cannot be used before it is initialized
error C3536: '$S3': cannot be used before it is initialized
error C2100: illegal indirection
error C2440: 'initializing' : cannot convert from 'int' to 'float *'

  • GCC 5.1（第 42 行）：

    error: no match for call to '(RowIterator<float>) ()'

  • Clang 3.7.0（第 42 行）：

    error: type 'RowIterator<float>' does not provide a call operator
note: when looking up 'begin' function for range expression of type 'details::Range<RowIterator<float> >'

所有编译器都在搜索调用运算符。为什么？ 据我了解，上述迭代器为范围循环提供了最小接口，并且在使用来自cppreference.com的语法等价代码时可以工作。

4

1 回答 1

1

在写这个问题时，我想出了解决方案（橡胶 SO 调试？）：编译器首先检查成员并尝试调用那些导致缺少调用运算符的Range::begin成员Range::end。没有一个经过测试的编译器在其错误消息中明确指出这一点[1]。解决方法是简单地重命名它们：

namespace range
{

template<class Iterator>
struct Range {
    // "begin" and "end" have ultra-special meaning in this context!!!
    Iterator range_begin, range_end;
    Range() { }
    Range(Iterator begin, Iterator end) : range_begin(begin), range_end(end) { }
};

template<class Iterator>
Iterator begin(const Range<Iterator>& range) { return range.range_begin; }
template<class Iterator>
Iterator end(const Range<Iterator>& range) { return range.range_end; }

}

类的要求Range定义明确（来源：cppreference.com，强调我的）：

begin_expr和end_expr定义如下：

1 如果range_expression是数组类型的表达式，则 begin_expr是__range，end_expr是 (__range + __bound)，其中__bound是数组中的元素个数（如果数组大小未知或类型不完整，则程序非良构）

2 如果range_expression是一个类类型 C 的表达式，它具有一个名为的成员begin和/或一个名为的成员end（无论此类成员的类型或可访问性如何），那么begin_expr__range.begin()和 end_expr是 __range.end()；

3 否则，begin_expr isbegin(__range)和end_expr is end(__range)，它们是通过参数相关查找找到的（不执行非 ADL 查找）。

[1]：Clang 实际上接近了，尽管它的信息是模棱两可的：我认为它是 (adl) 抬头details::begin(Range)而不是直视Range::begin。

于 2016-06-11T10:37:38.013 回答