std::find() 在 C 风格数组上向后？

说我需要使用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 to some_slice使用（更好）

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

因为那时std::find将从头开始而不是从尾部搜索。

另一方面，代码本身对我来说已经被破坏了，因为我不明白如何std::find将处理作为原始指针的“反向迭代器”。

在这种情况下修复代码的最佳方法是什么？有什么方法可以使用作为原始指针的反向迭代器吗？或者是否有一个标准的重构机制来解决这个问题，other比改变SOMESTRUCT?

我不太确定我理解这个问题（这可能是由于您似乎试图避免的迭代器方向的尴尬混合），但我只是将您的注意力引向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.elements[s.count]是未定义的行为，如果s.count is 256， 因为s.elements[s.count] is *(s.elements + s.count)，这不是要取消引用的有效数组元素。

在实践中，完整的表达式就可以了，因为&*x取消到x，但你可能仍然想避免它：

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

s.elements[-1]也可能是未定义的行为，尽管我认为严格来说这可能是合法的，因为你有一个int数组之前的成员。