Question

我在内存中有一个16字节宽的条目数组。每个条目由两个64位整数字段组成。根据每个条目的前64位整数的数值，条目按排序顺序排列。是否可以使用STL进行二进制搜索，而无需先将数据加载到std :: vector中？

我已经看到我可以在普通数组上使用STL lower_bound（）方法，但我需要它忽略每个条目的第二个64位字段。这可能吗？

Answer 1

您不需要使用std::vector<>，但如果您首先将数据转换为正确的数据类型，则最简单：

#include <cstdint>

struct mystruct
{
    std::int64_t first, second;
};

你的问题现在还不清楚你现在存储这些数据的方式，但我认为它就像上面那样。

然后，您可以为数据类型重载operator<：

#include <algorithm>

bool operator <(mystruct const& ms, std::int64_t const i)
{
    return ms.first < i;
}

int main()
{
    mystruct mss[10] = { /*populate somehow*/ };
    std::int64_t search_for = /*value*/;
    mystruct* found = std::lower_bound(mss, mss + 10, search_for);
}

或者您可以定义自定义比较器并将其传递给std::lower_bound：

#include <algorithm>

struct mystruct_comparer
{
    bool operator ()(mystruct const& ms, std::int64_t const i) const
    {
        return ms.first < i;
    }
};

int main()
{
    mystruct mss[10] = { /*populate somehow*/ };
    std::int64_t search_for = /*value*/;
    mystruct* found = std::lower_bound(mss,
                                       mss + 10,
                                       search_for,
                                       mystruct_comparer());
}

当然，在C ++ 11中，可以使用lambda代替比较器的完整仿函数。

Answer 2

struct Foo {
    int64_t lower;
    int64_t upper;
};

Foo arr[N];

Foo f;
f.lower = 42;

auto it = std::lower_bound(arr, arr + N, f,
    [](const Foo& lhs, const Foo& rhs){ return lhs.lower < rhs.lower; });

Answer 3

是的，这是可能的。您需要创建一个满足ForwardIterator要求的类，它以正确的方式迭代元素（16字节结构的指针可能会起作用）。然后你需要定义自己的比较以比较忽略第二个64位字段的元素。 more info

template <class ForwardIterator, class T, class Compare>
  ForwardIterator lower_bound ( ForwardIterator first, ForwardIterator last,
                                const T& value, Compare comp );

是否可以使用lower_bound（）二进制搜索一个简单的结构数组？

3 个答案: