Question

我想将矢量与数组进行比较，假设元素的顺序不同。我有一个像下面这样的结构（这个结构没有“operator ==”和“operator＆lt;” - ＆gt;所以我不能使用sort）：

struct A
{
    int index;
    A(int p_i) : index(p_i) {}
};

向量和数组的大小相同：

std::vector<A> l_v = {A(1), A(2), A(3)};
A l_a[3] = {A(3), A(1), A(2)};

我正在寻找一些来自std的函数，如下面的“some_function_X”，它可以使用lambda以特定方式找到元素，或者只能比较特定字段的函数，如“lhs.index == rhs.index” - ＆gt;在没有“operator ==”和“operator＆gt;”的类中的特定字段等

bool checkIfTheSame(const std::vector<A>& l_v, const A& l_a)
{
    for(usigned int i=0; i< 3; ++i)
    {
        if(!std::some_function_X(l_v.begin(), l_v.end(), l_a, 
                              [](const A& lhs, const A& rhs){
                                 return lhs.index == rhs.index;
                              })) return false;
    }
    return true;
}

感谢。

Answer 1

这个结构没有“operator ==”和“operator＆lt;” - ＆GT;所以我不能使用sort

首先，只需要operator<。其次，它不必被定义为成员函数。以下自由函数适用于std::less（如果您未通过仿函数进行比较，则std::sort使用此函数。）

bool operator<(const A& a, const A& b) {...}

或者，您可以使用自定义比较函数而不是std::less。

对数组和向量进行排序然后进行比较应该具有更好的渐近运行时复杂度，而不是简单地迭代一个并使用线性搜索检查元素是否存在于另一个中。

另一个想法是只对其中一个进行排序，迭代无序并使用二进制搜索测试已排序容器中的存在。它具有与排序两者相同的渐近复杂度。

如果您无法修改任何容器，则可以复制以进行排序。这需要一些记忆，但仍然比平凡的方法渐近快。 std::partial_sort_copy可以直接对副本进行排序，从而为您节省一些副本。

Answer 2

看这里：http://www.cplusplus.com/reference/algorithm/

使用lambda表达式find if

查找

只能比较特定字段的函数，如＆＃34; lhs.index == rhs.index＆＃34; - ＆GT;在没有＆＃34;运算符==＆＃34;的类中的特定字段和＆＃34;运算符＆gt;＆＃34;等

检查您的2个容器是否包含带谓词的相同数据：equal带有自定义谓词

如果您只想检查容器容器是否具有特定值，请查看此处：How to find if an item is present in a std::vector?

Answer 3

我不确定我完全理解你想要什么，但我猜你想要检查两个阵列（具有不同容器类型）是否等同于，数组A中的item在数组B的某处有一个对应的项，其中一些谓词返回true。

您希望在两个阵列上执行此操作，这两个阵列不仅具有不同类型，而且可能具有不同的顺序。

这是一种方法：

struct Foo
{
    Foo(int i) : _index { i } {}

    int index() const {
        return _index;
    }
private:
    int _index;
};

// params:
// first1, last1 bound the first array
// first2, last2 bound the second array
// pred is a predicate that checks for equivalents
// order is a predicate that performs weak ordering
template<class Iter1, class Iter2, class Pred, class Order>
bool checkIfTheSame(Iter1 first1, Iter1 last1, Iter2 first2, Iter2 last2, Pred pred, Order order)
{
    const auto len1 = last1 - first1;
    const auto len2 = last2 - first2;
    if (len1 != len2)
        return false;

    using namespace std;
    using item1_type = typename std::iterator_traits<Iter1>::value_type;
    using item2_type = typename std::iterator_traits<Iter2>::value_type;

    std::vector<std::reference_wrapper<item1_type>> refs1 { first1, last1 };
    std::sort(begin(refs1), end(refs1), order);

    std::vector<std::reference_wrapper<item2_type>> refs2 { first2, last2 };
    std::sort(begin(refs2), end(refs2), order);

    for (size_t i = 0 ; i < len1 ; ++i) {
        if (!pred(refs1[i], refs2[i]))
            return false;
    }

    return true;
}

简单的例子：

using namespace std;

bool same_indexes(const Foo& f1, const Foo& f2) {
    return f1.index() == f2.index();
}

bool sort_indexes(const Foo& f1, const Foo& f2) {
    return f1.index() < f2.index();
}

int main(int argc, const char * argv[])
{
    vector<Foo> x { 1, 2, 3 };
    Foo y[] = { 3, 2, 1 };

    cout << checkIfTheSame(begin(x), end(x), begin(y), end(y), same_indexes, sort_indexes) << endl;

    return 0;
}

Answer 4

如果你没有办法对数组或向量进行排序，但是你只能知道两个元素是否相等，那么唯一的方法就是穷举搜索。

如何以有效的方式以特定的方式比较矢量和数组？

4 个答案: