std::find() 在 C 样式数组上倒退？

Question

说我需要使用s：

typedef struct tagSOMESTRUCT   // Defined by someone else; C-compatible
{
    int count;
    int elements[256];
} SOMESTRUCT;

SOMESTRUCT s;

说我有这样的功能：

template<typename RevFwdIt>
std::pair<RevFwdIt, RevFwdIt> some_slice_rev(RevFwdIt rbegin, RevFwdIt rend)
{
    RevFwdIt it = basename_rev(rbegin, rend);
    RevFwdIt e = std::find(rbegin, it, 5);
    return std::make_pair(e == it ? rbegin : e, it);
}

为了使用这个功能，我需要说

some_slice_rev(&s.elements[s.count - 1], &s.elements[-1]);

哪一个（恕我直言）是丑陋且容易出错的，因为存在非一个错误。

一方面，我不能简单地将some_slice_rev 更改为some_slice 以使用（更好）

some_slice(&s.elements[0], &s.elements[s.count]);

因为std::find 会从头而不是尾搜索。

另一方面，代码本身在我看来已经损坏，因为我看不出std::find 将如何处理作为原始指针的“反向迭代器”。

在这种情况下修复代码的最佳方法是什么？有没有办法使用作为原始指针的反向迭代器？或者，除了更改SOMESTRUCT，其他是否有解决此问题的标准重构机制？

Answer 1

我不太确定我是否理解这个问题（这可能是由于您似乎试图避免的迭代器方向的尴尬混合），但我只是将您的注意力引向std::reverse_iterator：

#include <iostream>
#include <iterator>

// for example
template <typename Iter>
void print_it(Iter first, Iter last)
{
    std::cout << '|';

    for (; first != last; ++first)
        std::cout << ' ' << *first << " |";

    std::cout << std::endl;
}

int main()
{
    int arr[10] = {1, 2, 3, 4};

    int *begin = arr, *end = arr + 4;

    print_it(begin, end);
    print_it(std::reverse_iterator<int*>(end),
                std::reverse_iterator<int*>(begin));
}

它们像双向迭代器一样工作，除了 ++ 在内部是 --，反之亦然。

请注意，它有点难看。您可能需要一些实用功能：

#include <iostream>
#include <iterator>

// for example
template <typename Iter>
void print_it(Iter first, Iter last)
{
    std::cout << '|';

    for (; first != last; ++first)
        std::cout << ' ' << *first << " |";

    std::cout << std::endl;
}

template <typename Iter>
std::reverse_iterator<Iter> make_reverse_iterator(Iter iter)
{
    return std::reverse_iterator<Iter>(iter);
}

int main()
{
    int arr[10] = {1, 2, 3, 4};

    int *begin = arr, *end = arr + 4;

    print_it(begin, end);
    print_it(make_reverse_iterator(end),
                make_reverse_iterator(begin));
}

---

所以我想你想要这个：

template<typename ForwardIterator >
std::pair<ForwardIterator, ForwardIterator>
    some_slice(ForwardIterator begin, ForwardIterator end)
{
    typedef std::reverse_iterator<ForwardIterator> rev_iter;

    rev_iter it = basename(rev_iter(end), rev_iter(begin));
    rev_iter e = std::find(rev_iter(end), it, 5);

    return std::make_pair(it.base(), e.base());
}

---

现在相对偏离主题，但请注意，如果 s.count 是 256，s.elements[s.count] 是未定义的行为，因为 s.elements[s.count] 是 *(s.elements + s.count)，这不是要取消引用的有效数组元素。

实际上，完整的表达式很好，因为&*x 抵消了x，但您仍然可能想避免它：

some_slice(s.elements, s.elements + s.count);

s.elements[-1] 也可能是未定义的行为，但我认为严格来说它可能是偶然的，因为您在数组之前有一个 int 成员。

Answer 2

一个简单的解决方案是编写一个包装迭代器类来模拟反向迭代器，然后使用它来代替原始数组迭代器，像往常一样使用std::find。所以当std::find 调用++it 时，它会调用operator++，这会在内部递减实际的迭代器--rawIt。这就是其他标准反向迭代器所做的。