如何在 C++ 中比较两个非随机访问迭代器

Question

我有这个：

vector<int> vec = {10, 4, 18, 7, 2, 10, 25, 30};
auto& pos25 = find(vec.cbegin(), vec.cend(), 25);
auto& pos18 = find(vec.cbegin(), vec.cend(), 18);

现在，我想查询两个位置之间的 7。我可以在pos25 和pos18 之间使用operator<，因为它们是随机访问迭代器，然后我可以find 在该范围内找到7 的位置。

但是如果我的容器是forward_list。我将如何实现它，因为我没有 operator< 来比较这两个迭代器；因此我不知道是 pos25 还是 pos18 首先出现给 find 函数一个范围。

我在一本书中找到了这个方法：

pos18 = find (vec.begin(), vec.end(), // range
18); // value
pos25 = find (vec.begin(), pos18, // range
25); // value
if (pos18 != coll.end() && pos25 != pos18) {
// pos25 is in front of pos18
// so, only [pos25,pos18) is valid
...
}
else {
pos25 = find (pos25, vec.end(), // range
25); // value
if (pos25 != coll.end()) {
// pos18 is in front of pos25
// so, only [pos18,pos25) is valid
...
}
else {
// 18 and/or 25 not found
...
}
}

虽然这很简单，但还有什么更高效的吗？

Answer 1

迭代链表的成本相对较高，因为必须进行对内存的潜在访问。您将希望最小化这些访问。为此，您可以做几件事：

1. 使用find_if 搜索18 或25
2. 然后使用find_if 再次搜索从该点以查找7 或另一个边界
3. 如果在第 1^st 找到另一个边界，则没有干预 7 如果首先找到 7，则确保另一个边界存在李>

所以您的代码可能如下所示：

const auto start = find_if(cbegin(vec), cend(vec), [](const auto& i){ return i == 18 || i == 25; });
const auto target = find_if(start, cend(vec), [finish = *start == 18 ? 25 : 18](const auto& i){ return i == 7 || i == finish; });
const auto finish = *target == 7 ? find(target, cend(vec), *start == 18 ? 25 : 18) : cend(vec);

在此之后，如果 finish 不指向 cend(vec)，则 target 是指向范围内第 1^st7 的有效指针。

Live Example

---

Vlad from Moscow's solution 通过使用find_first_of 巧妙地避免了对 lambdas 的需求，但它不止一次地迭代了vec 的内容，这使得它比我的算法更昂贵。这两种算法的结合产生了一种比我原来的算法更快的算法，同时保留了每个元素只访问一次的好处：

const int a[] = { 18, 25 };
const auto start = find_first_of(cbegin(vec), cend(vec), cbegin(a), cend(a));
const int b[] = { *start == *cbegin(a) ? *crbegin(a) : *cbegin(a), 7 };
const auto target = find_first_of(start, cend(vec), cbegin(b), cend(b));
const auto finish = *target == *crbegin(b) ? find(target, cend(vec), *cbegin(b)) : cend(vec);

同样，如果finish 不指向cend(vec)，那么target 是指向范围内第一个^st 7 的有效指针。

Live Example

Answer 2

对于初学者，此代码 sn-p（如果要更新错字）是错误的

vector<int> vec = {10, 4, 18, 7, 2, 10, 25, 30};
auto& pos25 = find(vec.cbegin(), vec.cend(), 25);
auto& pos18 = find(vec.cbegin(), vec.cend(), 18);

您不能将临时对象与非常量引用绑定。

至于这种做法

pos18 = find (vec.begin(), vec.end(), // range
18); // value
pos25 = find (vec.begin(), pos18, // range
25); // value

那么您将需要检查许多条件。例如在调用之前

pos25 = find (vec.begin(), pos18, // range
25); // value

你应该检查pos19是否不等于vec.end()。

至于确定哪个迭代器小于或大于您可以使用标准函数std::distance。但是，它应用于容器std::forward_list 的迭代器时效率低下。

一种更有效的方法是使用标准算法std::find_first_of 而不是算法std::find 来查找范围的第一个迭代器。

这是一个演示程序

#include <iostream>
#include <vector>
#include <algorithm>
#include <iterator>

int main()
{
    std::vector<int> vec = { 10, 4, 18, 7, 2, 10, 25, 30 };
    int a[] = { 25, 18 };

    auto first = std::find_first_of(vec.cbegin(), vec.cend(),
        std::begin(a), std::end(a));

    auto last = vec.cend();
    auto target = vec.cend();

    if (first != vec.cend())
    {
        last = std::find(first, vec.cend(),
            *first == a[0] ? a[1] : a[0]);
    }

    if (last != vec.cend())
    {
        target = std::find(first, last, 7);
    }

    if (target != vec.end())
    {
        std::cout << 7 << " is between " << *first
            << " and " << *last << std::endl;
    }
}

程序输出是

7 is between 18 and 25

Answer 3

除了operator == 之外，您没有任何选项可以比较两个ForwardIterator。这意味着您在这里只有两种方式：

1. 使用std::find 确保迭代器属于数组的特定部分。此方法在您引用的代码和@Jonathan 的答案中实现。
2. 通过为此类操作编写特殊过程来比较两个迭代器。

例如，可以编写如下代码：

template<typename ForwardIterator>
bool less(ForwardIterator lhs, ForwardIterator rhs, ForwardIterator end) {
    if (lhs == rhs) {
        return false; // Equal
    }
    while (lhs++ != end) {
        if (lhs == rhs) {
            return true; // rhs is after lhs
        }
    }
    return false; // lhs is after rhs
}

还请注意，此过程假定两个迭代器属于同一个容器并且具有线性时间复杂度。

就个人而言，我建议在这种情况下使用RandomAccessIterator。是的，std::list 不提供，但您可以改用std::vector。